InterSystems ObjectScript est un langage de script permettant d'opérer avec des données en utilisant n'importe quel modèle de données de la plateforme de données InterSystems (objets, relationnel, clé-valeur, document, globales) et de développer une logique métier pour les applications côté serveur sur la plateforme de données InterSystems.
Bonjour
Je vous soumets cet article en tant qu’état de l’art enrichi.
L’objectif est de réunir les différentes façons d’importer et d’exporter des CSV en un seul endroit.
Cet article est basé sur InterSystems 2024.1 .
N'hésitez pas à commenter pour rajouter des précisions.
Si vous voulez une deuxième partie sur l'export de CSV, faites le moi savoir.
Commençons par une question simple et motivante : au cours des 14 derniers jours, quelles sont les erreurs les plus courantes dans le Journal des erreurs d'application?
Répondre à cette question via le portail de gestion ou le terminal est un processus manuel fastidieux. Nous devrions pouvoir simplement utiliser SQL. Heureusement, quelques requêtes de classe sont disponibles pour vous aider dans la classe SYS.ApplicationError de l'espace de noms %SYS. Vous pouvez répondre à cette question pour une seule date à l'aide d'une commande telle que:
select"Error message",count(*)
from SYS.ApplicationError_ErrorList('CCR','12/16/2024')
groupby"Error message"orderby2descMalheureusement, la structure des requêtes de classe est soumise aux mêmes contraintes structurelles générales que les pages du portail de gestion ; la requête ErrorList nécessite un espace de noms et une date. Il existe sûrement une meilleure approche que de faire 14 appels conjoints à cette requête de classe pour différentes dates, n'est-ce pas ? D'une certaine manière, c'est un véritable problème. S'il existe une bonne façon de procéder avec du SQL classique et que je l'ai simplement manquée, merci de me le faire savoir!
Logiquement, il convient de rédiger notre propre requête de classe personnalisée. Cela implique d'ajouter un membre de classe Query (par exemple <QueryName>) et d'implémenter des méthodes nommées <QueryName>Execute, <QueryName>Fetch et <QueryName>Close. De manière générale, la méthode Execute configure le contexte de la requête de classe et effectue toutes les tâches initiales, en conservant l'état dans qHandle. La méthode Fetch récupère une seule ligne et indique si toutes les lignes ont été trouvées ou non. Enfin, la méthode Close effectue le nettoyage final. Par exemple, si l'implémentation des méthodes Execute/Fetch utilise une variable globale privée au processus, la méthode Close peut la supprimer.
N'oubliez pas d'ajouter un indicateur [ SqlProc ] magique au membre Query afin qu'il puisse être appelé en tant que TVF (fonction table) à partir d'autres requêtes SQL!
Ci-dessous, vous trouverez un exemple complet fonctionnel:
/// Requêtes utilitaires pour aider à accéder au journal des erreurs de l'application à partir de SQLClass AppS.Util.ApplicationErrorLog
{
/// Renvoi de toutes les erreurs d'application (toutes dates confondues) à partir du journal des erreurs d'application
Query All() As%Query(ROWSPEC = "Date:%Date,ErrorNumber:%Integer,ErrorMessage:%String,Username:%String") [ SqlProc ]
{
}
/// Récupèration d'une liste de dates comportant des erreurs et la stocke dans qHandleClassMethod AllExecute(ByRef qHandle As%Binary) As%Status
{
Set ns = $NamespaceNew$NamespaceSet$Namespace = "%SYS"Set stmt = ##class(%SQL.Statement).%New()
Set stmt.%SelectMode = 0Set result = ##class(%SQL.Statement).%ExecDirect(stmt,"select %DLIST(""Date"") ""Dates"" from SYS.ApplicationError_DateList(?)",ns)
$$$ThrowSQLIfError(result.%SQLCODE,result.%Message)
If 'result.%Next(.sc) {
Return sc
}
Set qHandle("list") = result.%Get("Dates")
Set qHandle("pointer") = 0Quit$$$OK
}
/// Récupèreation de la ligne suivante, en passant à la date suivante si nécessaireClassMethod AllFetch(ByRef qHandle As%Binary, ByRef Row As%List, ByRef AtEnd As%Integer = 0) As%Status [ PlaceAfter = AllExecute ]
{
Set sc = $$$OKSet ns = $NamespaceNew$NamespaceSet$Namespace = "%SYS"If$Get(qHandle("dateResult")) = "" {
// Passage à la date suivanteSet pointer = qHandle("pointer")
If '$ListNext(qHandle("list"),pointer,oneDate) {
Set AtEnd = 1Quit$$$OK
}
Set qHandle("pointer") = pointer
Set qHandle("currentDate") = oneDate
Set qHandle("dateResult") = ##class(%SQL.Statement).%ExecDirect(,"select * from SYS.ApplicationError_ErrorList(?,?)",ns,oneDate)
$$$ThrowSQLIfError(qHandle("dateResult").%SQLCODE,qHandle("dateResult").%Message)
}
If qHandle("dateResult").%Next(.sc) {
// Si nous avons une ligne pour la date actuelle, ajoutons-laSet Row = $ListBuild(qHandle("currentDate"),qHandle("dateResult").%GetData(1),qHandle("dateResult").%GetData(2),qHandle("dateResult").%GetData(6))
} ElseIf$$$ISOK(sc) {
// Sinon, il faut vider le jeu de résultats et appeler AllFetch pour avancerSet qHandle("dateResult") = ""Set$Namespace = ns
Set sc = ..AllFetch(.qHandle,.Row,.AtEnd)
}
Quit sc
}
ClassMethod AllClose(ByRef qHandle As%Binary) As%Status [ PlaceAfter = AllExecute ]
{
New$NamespaceSet$Namespace = "%SYS"// Il semble parfois nécessaire pour que %OnClose s'exécute correctementKill qHandle("dateResult")
Quit$$$OK
}
}
Dans cet exemple, nous commençons dans un espace de noms utilisateur, mais toutes les requêtes s'exécutent en réalité dans %SYS. Execute obtient une liste des dates d'erreur pour l'espace de noms actuel et la stocke dans qHandle. Fetch passe à la date suivante lorsque cela est approprié, puis renvoie l'erreur suivante pour la date actuelle. Et Close s'assure que la requête de classe sort de la portée dans %SYS, car j'obtenais parfois des erreurs si ce n'était pas le cas. C'était un peu surprenant, mais cela semble logique, car la requête de classe que nous appelons n'existe que dans %SYS.
La réutilisabilité des fonctions table offre de nombreuses possibilités. Par exemple, nous pouvons en ajouter une autre dans la même classe:
/// Obtenir le nombre d'erreurs survenues au cours des derniers <var>Days</var> jours
Query ErrorCounts(Days As%Integer) As%SQLQuery(ROWSPEC = "Occurrences:%Integer,ErrorMessage:%String") [ SqlProc ]
{
SELECT COUNT(*) AS Occurrences, ErrorMessage
FROM AppS_Util.ApplicationErrorLog_All()
WHERE DATEDIFF(D,"Date",$h) <= :Days
GROUP BY ErrorMessage
ORDER BY Occurrences DESC
}Et maintenant, pour obtenir les erreurs d'application les plus courantes au cours des 14 derniers jours, il suffit de:
call AppS_Util.ApplicationErrorLog_ErrorCounts(14)Maintenant, il ne nous reste plus qu'à les corriger! 😅
Dans cette section, nous allons découvrir comment utiliser Python comme langage principal dans IRIS, ce qui vous permettra d'écrire la logique de votre application en Python tout en profitant de la puissance d'IRIS.
Tout d'abord, nous allons commencer par la méthode officielle, qui consiste à la mise en œuvre de l'interpréteur irispython.
Vous pouvez utiliser l'interpréteur irispython pour exécuter du code Python directement dans IRIS. Cela vous permet d'écrire du code Python et de l'exécuter dans le contexte de votre application IRIS.
irispython est un interpréteur Python qui se trouve dans le répertoire d'installation d'IRIS (<installation_directory>/bin/irispython) et qui sert à exécuter du code Python dans le contexte d'IRIS.
Cela vous permettra :
sys.path pour inclure les bibliothèques et les modules Python IRIS.
site.py, qui se trouve dans <installation_directory>/lib/python/iris_site.py.iris, qui sont des modules spéciaux permettant d'accéder aux fonctionnalités IRIS, telles que la conversion de n'importe quelle classe ObjectScript vers Python, et réciproquement.Vous pouvez exécuter l'interpréteur irispython à partir de la ligne de commande:
<installation_directory>/bin/irispython
Prenons un exemple simple:
# src/python/article/irispython_example.py
import requests
import iris
def run():
response = requests.get("https://2eb86668f7ab407989787c97ec6b24ba.api.mockbin.io/")
my_dict = response.json()
for key, value in my_dict.items():
print(f"{key}: {value}") # print message: Hello World
return my_dict
if __name__ == "__main__":
print(f"Iris version: {iris.cls('%SYSTEM.Version').GetVersion()}")
run()
Vous pouvez lancer ce script à l'aide de l'interpréteur irispython:
<installation_directory>/bin/irispython src/python/article/irispython_example.py
Vous verrez le résultat:
Iris version: IRIS for UNIX (Ubuntu Server LTS for x86-64 Containers) 2025.1 (Build 223U) Tue Mar 11 2025 18:23:31 EDT
message: Hello World
Il est présenté ici comment utiliser l'interpréteur irispython pour exécuter du code Python dans le contexte d'IRIS.
irispython n'est pas aussi simple que dans un environnement Python dédié.
irispython.
python ou python3, ce qui n'est pas le cas dans IRIS.En conclusion, en utilisant irispython, vous pouvez écrire la logique de votre application en Python tout en profitant de la puissance d'IRIS. Cependant, cet outil présente certaines limites en matière de débogage et de configuration de l'environnement virtuel.
Dans cette section, nous allons découvrir comment utiliser WSGI (Interface de passerelle serveur Web) pour exécuter des applications Web Python dans IRIS.
WSGI est une interface standard entre les serveurs Web et les applications ou frameworks Web Python. Elle vous permet d'exécuter des applications Web Python dans un environnement de serveur Web.
IRIS prend en charge WSGI, ce qui signifie que vous pouvez exécuter des applications Web Python dans IRIS à l'aide du serveur WSGI intégré.
Pour utiliser WSGI dans IRIS, vous devez créer une application WSGI et l'enregistrer auprès du serveur web IRIS.
Pour plus de détails, consultez la documentation officielle.
Vous trouverez un template complet ici iris-flask-example.
uvicorn ou gunicorn avec un framework web Python.En conclusion, l'utilisation de WSGI dans IRIS vous permet de créer des applications web puissantes à l'aide de Python tout en profitant des fonctionnalités et des capacités d'IRIS.
Dans cette section, nous allons découvrir comment utiliser l'API Python DB pour interagir avec les bases de données IRIS.
L'API Python DB est une interface standard pour se connecter à des bases de données en Python. Elle vous permet d'exécuter des requêtes SQL et de récupérer les résultats dans la base de données.
Vous pouvez l'installer en utilisant pip:
pip install intersystems-irispython
Ensuite, vous pouvez utiliser l'API DB pour la connexion à une base de données IRIS et exécuter des requêtes SQL.
Vous l'utilisez comme n'importe quelle autre API Python DB. Voici un exemple:
# src/python/article/dbapi_example.py
import iris
def run():
# Connexion à la base de données IRIS
# Ouverture d'une connexion au serveur
args = {
'hostname':'127.0.0.1',
'port': 1972,
'namespace':'USER',
'username':'SuperUser',
'password':'SYS'
}
conn = iris.connect(**args)
# Création d'un curseur
cursor = conn.cursor()
# Exécution d'une requête
cursor.execute("SELECT 1")
# Récupération de tous les résultats
results = cursor.fetchall()
for row in results:
print(row)
# Fermeture du curseur et de la connexion
cursor.close()
conn.close()
if __name__ == "__main__":
run()
Ce script peut être exécuté à l'aide de n'importe quel interpréteur Python:
python3 /irisdev/app/src/python/article/dbapi_example.py
Vous verrez le résultat:
(1,)
Il existe également une édition communautaire de la DB-API, disponible ici : intersystems-irispython-community.
Elle offre une meilleure prise en charge de SQLAlchemy, Django, langchain et d'autres bibliothèques Python qui utilisent la DB-API.
Pour plus de détail, consultez la Section supplémentaire.
En conclusion, l'utilisation de l'API Python DB avec IRIS vous permet de créer des applications puissantes capables d'interagir de manière transparente avec votre base de données.
Après avoir vu comment utiliser Python dans IRIS, nous allons découvrir comment utiliser Jupyter Notebooks avec IRIS.
Jupyter Notebooks est un excellent moyen d'écrire et d'exécuter du code Python de manière interactive. Il peut être utilisé avec IRIS pour profiter de ses fonctionnalités.
Pour utiliser Jupyter Notebooks avec IRIS, vous devez installer les packages notebook et ipykernel:
pip install notebook ipykernel
Ensuite, vous pouvez créer un nouveau Jupyter Notebook et sélectionner le noyau Python 3.
Vous pouvez créer un nouveau Jupyter Notebook et écrire le code suivant:
# src/python/article/my_notebook.ipynb
# Importation des modules nécessaires
import iris
# La magie
iris.system.Version.GetVersion()
Vous pouvez exécuter ce notebook à l'aide de Jupyter Notebook:
jupyter notebook src/python/article/my_notebook.ipynb
Pour conclure, l'utilisation des notebooks Jupyter avec IRIS vous permet d'écrire et d'exécuter du code Python de manière interactive tout en profitant des fonctionnalités d'IRIS. Cependant, la configuration peut s'avérer délicate, en particulier au niveau du noyau.
À partir de cette section, nous aborderons certains sujets avancés liés à Python dans IRIS, tels que le débogage à distance du code Python ou encore l'utilisation d'environnements virtuels.
La plupart de ces sujets ne sont pas officiellement pris en charge par InterSystems, mais il est utile de les aborder si vous souhaitez utiliser Python dans IRIS.
irispython)Dans cette section, nous allons voir comment utiliser un interpréteur Python natif au lieu de l'interpréteur irispython.
Cela vous permet d'utiliser des environnements virtuels prêts à l'emploi et d'utiliser l'interpréteur Python auquel vous êtes habitué.
Pour utiliser un interpréteur Python natif, vous devez installer IRIS localement sur votre machine et disposer du package iris-embedded-python-wrapper installé.
Vous pouvez l'installer avec pip:
pip install iris-embedded-python-wrapper
Ensuite, vous devez configurer certaines variables d'environnement pour faire référence à votre installation IRIS:
export IRISINSTALLDIR=<installation_directory>
export IRISUSERNAME=<username>
export IRISPASSWORD=<password>
export IRISNAMESPACE=<namespace>
Ensuite, vous pouvez exécuter votre code Python à l'aide de votre interpréteur Python natif:
python3 src/python/article/irispython_example.py
# src/python/article/irispython_example.py
import requests
import iris
def run():
response = requests.get("https://2eb86668f7ab407989787c97ec6b24ba.api.mockbin.io/")
my_dict = response.json()
for key, value in my_dict.items():
print(f"{key}: {value}") # message d'impression: Hello World
return my_dict
if __name__ == "__main__":
print(f"Iris version: {iris.cls('%SYSTEM.Version').GetVersion()}")
run()
Pour plus de détails; consultez iris-embedded-python-wrapper documentation.
pdb ou ipdb, pour déboguer votre code Python dans IRIS.iris-embedded-python-wrapper peut s'avérer complexe, en particulier pour les débutants.Dans cette section, nous allons explorer l'édition communautaire de l'API DB, disponible sur GitHub.
Vous pouvez l'installer avec pip:
pip install sqlalchemy-iris
Cette option installe l'édition communautaire de DB-API.
Ou avec une version spécifique:
pip install https://github.com/intersystems-community/intersystems-irispython/releases/download/3.9.3/intersystems_iris-3.9.3-py3-none-any.whl
Ensuite, vous pouvez utiliser l'API DB pour vous connecter à une base de données IRIS et exécuter des requêtes SQL ou tout autre code Python qui utilise l'API DB, comme SQLAlchemy, Django, langchain, pandas, etc.
Vous pouvez l'utiliser comme n'importe quelle autre API Python DB. Exemple:
# src/python/article/dbapi_community_example.py
import intersystems_iris.dbapi._DBAPI as dbapi
config = {
"hostname": "localhost",
"port": 1972,
"namespace": "USER",
"username": "_SYSTEM",
"password": "SYS",
}
with dbapi.connect(**config) as conn:
with conn.cursor() as cursor:
cursor.execute("select ? as one, 2 as two", 1) # le deuxième argument est la valeur du paramètre
for row in cursor:
one, two = row
print(f"one: {one}")
print(f"two: {two}")
Vous pouvez exécuter ce script à l'aide de n'importe quel interpréteur Python:
python3 /irisdev/app/src/python/article/dbapi_community_example.py
Ou à l'aide de sqlalchemy:
from sqlalchemy import create_engine, text
COMMUNITY_DRIVER_URL = "iris://_SYSTEM:SYS@localhost:1972/USER"
OFFICIAL_DRIVER_URL = "iris+intersystems://_SYSTEM:SYS@localhost:1972/USER"
EMBEDDED_PYTHON_DRIVER_URL = "iris+emb:///USER"
def run(driver):
# Création d'un moteur à l'aide du pilote officiel
engine = create_engine(driver)
with engine.connect() as connection:
# Exécution d'une requête
result = connection.execute(text("SELECT 1 AS one, 2 AS two"))
for row in result:
print(f"one: {row.one}, two: {row.two}")
if __name__ == "__main__":
run(OFFICIAL_DRIVER_URL)
run(COMMUNITY_DRIVER_URL)
run(EMBEDDED_PYTHON_DRIVER_URL)
Vous pouvez exécuter ce script à l'aide de n'importe quel interpréteur Python:
python3 /irisdev/app/src/python/article/dbapi_sqlalchemy_example.py
Vous verrez le résultat:
one: 1, two: 2
one: 1, two: 2
one: 1, two: 2
Dans cette section, nous allons voir comment déboguer du code Python dans IRIS.
Par défaut, le débogage du code Python dans IRIS (dans objectscript avec la balise de langage ou %SYS.Python) n'est pas possible, mais la communauté a trouvé une solution pour vous permettre de déboguer le code Python dans IRIS.
Installez d'abord IoP Interopérabilité en Python:
pip install iris-pex-embedded-python
iop --init
Cela installera IoP et les nouvelles classes ObjectScript qui vous permettront de déboguer le code Python dans IRIS.
Ensuite, vous pouvez utiliser la classe IOP.Wrapper pour encapsuler votre code Python et activer le débogage.
Class Article.DebuggingExample Extends %RegisteredObject
{
ClassMethod Run() As %Status
{
set myScript = ##class(IOP.Wrapper).Import("my_script", "/irisdev/app/src/python/article/", 55550) // Ajustez le chemin d'accès à votre module
Do myScript.run()
Quit $$$OK
}
}
Configurez ensuite VsCode pour utiliser le débogueur IoP en ajoutant la configuration suivante à votre fichier launch.json:
{
"version": "0.2.0",
"configurations": [
{
"name": "Python in IRIS",
"type": "python",
"request": "attach",
"port": 55550,
"host": "localhost",
"pathMappings": [
{
"localRoot": "${workspaceFolder}/src/python/article",
"remoteRoot": "/irisdev/app/src/python/article"
}
]
}
]
}
Vous pouvez désormais exécuter votre code ObjectScript qui importe le module Python, puis connecter le débogueur dans VsCode au port 55550.
Vous pouvez exécuter ce script à l'aide de la commande suivante:
iris session iris -U IRISAPP '##class(Article.DebuggingExample).Run()'
Vous pouvez ensuite définir des points d'arrêt dans votre code Python, et le débogueur s'arrêtera à ces points d'arrêt, ce qui vous permettra d'inspecter les variables et de parcourir le code.
Vidéo de débogage à distance en action (pour IoP, mais le concept est le même):
Et vous disposez également de tracebacks dans votre code Python, ce qui est très utile pour le débogage.
Avec les tracebacks activés:
Avec les tracebacks désactivés:
En conclusion, le débogage de code Python dans IRIS est possible grâce à la solution communautaire IoP, qui vous permet d'utiliser le débogueur Python pour déboguer votre code Python exécuté dans IRIS. Cependant, cela nécessite une certaine configuration et peut ne pas être aussi stable que les solutions officielles.
Dans cette section, nous allons explorer la solution IoP (Interopérabilité en Python), qui vous permet d'exécuter du code Python dans IRIS dans une approche "Python d'abord".
Je développe cette solution depuis un certain temps déjà, c'est mon bébé, elle essaie de résoudre ou d'améliorer tous les points précédents que nous avons vus dans cette série d'articles.
Points clés de l'IoP:
Pour en savoir plus sur IoP, vous pouvez consulter la documentation officielle.
Vous pouvez ensuite lire les articles suivants pour en savoir plus sur IoP:
🐍❤️ Comme vous pouvez le constater, IoP offre un moyen puissant d'intégrer Python à IRIS, ce qui facilite le développement et le débogage de vos applications.
Vous n'avez plus besoin d'utiliser irispython, vous n'avez plus à définir manuellement votre sys.path, vous pouvez utiliser des environnements virtuels et vous pouvez déboguer votre code Python exécuté dans IRIS.
J'espère que vous avez apprécié cette série d'articles sur Python dans IRIS.
N'hésitez pas à me contacter si vous avez des questions ou des commentaires à propos de cette série d'articles.
Bonne chance, amusez-vous avec Python dans IRIS!
Connaissant désormais bien Python et ses fonctionnalités, voyons comment nous pouvons tirer parti de Python dans IRIS.
La balise de langue est une fonctionnalité d'IRIS qui vous permet d'écrire du code Python directement dans vos classes ObjectScript.
Cette fonctionnalité est utile pour le prototypage rapide ou lorsque vous souhaitez utiliser les fonctionnalités de Python sans créer de script Python séparé.
Pour utiliser la balise de langue, il faut définir une méthode de classe avec l'attribut Language = python. Exemple:
Class Article.LanguageTagExample Extends %RegisteredObject
{
ClassMethod Run() [ Language = python ]
{
import requests
response = requests.get("https://2eb86668f7ab407989787c97ec6b24ba.api.mockbin.io/")
my_dict = response.json()
for key, value in my_dict.items():
print(f"{key}: {value}") # print message: Hello World
}
}
Quels sont donc les avantages et les inconvénients de l'utilisation de la balise de langue?
La balise de langue est une fonctionnalité puissante qui vous permet d'écrire du code Python directement dans vos classes ObjectScript. Cependant, elle a ses limitations et il est important de l'utiliser de manière raisonnable. Pour les projets plus importants ou lorsque vous devez déboguer votre code Python, il est préférable de créer des scripts Python séparés et de les importer dans vos classes ObjectScript.
Maintenant que nous avons une bonne compréhension de la balise de langue, voyons comment importer des modules Python et les utiliser dans ObjectScript.
Tout d'abord, nous allons nous limiter aux modules intégrés et aux modules tiers provenant de PyPI, tels que module de demande requests, module numpy, etc.
Ici, nous allons faire la même chose, mais en utilisant uniquement le module de demande de PyPI.
Class Article.RequestsExample Extends %RegisteredObject
{
ClassMethod Run() As %Status
{
set builtins = ##class(%SYS.Python).Import("builtins")
Set requests = ##class(%SYS.Python).Import("requests")
Set response = requests.get("https://2eb86668f7ab407989787c97ec6b24ba.api.mockbin.io/")
Set myDict = response.json()
for i=0:1:builtins.len(myDict)-1 {
set key = builtins.list(myDict.keys())."__getitem__"(i)
set value = builtins.list(myDict.values())."__getitem__"(i)
write key, ": ", value, !
}
}
}
Exécutons-le:
iris session iris -U IRISAPP '##class(Article.RequestsExample).Run()'
Vous verrez le résultat:
message: Hello World
En conclusion, l'importation de modules Python dans ObjectScript peut considérablement améliorer les capacités de votre application en tirant parti du vaste écosystème de bibliothèques Python. Cependant, il est essentiel de comprendre les compromis impliqués, tels que la nécessité d'une solide maîtrise de Python.
Continuons avec le même exemple, mais cette fois-ci, nous allons créer un module Python personnalisé et l'importer dans ObjectScript.
Cette fois-ci, nous utiliserons Python autant que possible, et ObjectScript ne sera utilisé que pour appeler le code Python.
Créons un module Python personnalisé dénommé my_script.py avec le contenu suivant:
import requests
def run():
response = requests.get("https://2eb86668f7ab407989787c97ec6b24ba.api.mockbin.io/")
my_dict = response.json()
for key, value in my_dict.items():
print(f"{key}: {value}") # print message: Hello World
Maintenant, nous allons créer une classe ObjectScript pour importer et exécuter ce module Python:
Class Article.MyScriptExample Extends %RegisteredObject
{
ClassMethod Run() As %Status
{
set sys = ##class(%SYS.Python).Import("sys")
do sys.path.append("/irisdev/app/src/python/article") // Adjust the path to your module
Set myScript = ##class(%SYS.Python).Import("my_script")
Do myScript.run()
Quit $$$OK
}
}
Maintenant, exécutons-le:
iris session iris -U IRISAPP '##class(Article.MyScriptExample).Run()'
⚠️ N'oubliez pas de modifier votre session iris afin de vous assurer que vous disposez de la dernière version du code. Pour plus d'informations, consultez le premier article. Vous verrez le résultat:
message: Hello World
Voici une démonstration de l'importation d'un module Python personnalisé dans ObjectScript et de l'exécution de son code.
sys.path.En conclusion, l'importation de modules Python dans ObjectScript peut considérablement améliorer les capacités de votre application en tirant parti du vaste écosystème de bibliothèques Python. Cependant, il est essentiel de comprendre les compromis impliqués, tels que la nécessité d'une solide maîtrise de Python.
Ce court article est consacré aux méthodes dunder de Python, également appelées méthodes magiques.
Les méthodes Dunder sont des méthodes spéciales en Python qui commencent et se terminent par deux traits de soulignement (__). Elles vous permettent de définir le comportement de vos objets pour les opérations intégrées, telles que l'addition, la soustraction, la représentation sous forme de chaîne, etc.
Parmi les méthodes dunder courantes, on peut citer:
__init__(self, ...): Appelé lorsqu'un objet est créé.
%OnNew dans ObjectScript.__str__(self): Appelée par la fonction intégrée str() et print pour représenter l'objet sous forme de chaîne.__repr__(self): Appelée par la fonction intégrée repr() pour représenter l'objet à des fins de débogage.__add__(self, other): Appelée lorsque l'opérateur + est utilisé.__len__(self): Appelée par la fonction intégrée len() pour renvoyer la longueur de l'objet.__getitem__(self, key): Appelée pour récupérer un élément d'une collection à l'aide de la syntaxe d'indiçage.__setitem__(self, key, value): Appelée pour définir un élément dans une collection à l'aide de la syntaxe d'indiçage.Dans ObjectScript, nous n'avons pas de sucre syntaxique comme en Python, mais nous pouvons obtenir un comportement similaire à l'aide des méthodes dunder.
Exemple : nous avons importé un module Python qui contient une fonction renvoyant une liste Python, et nous souhaitons l'utiliser dans ObjectScript. Nous devons utiliser la méthode dunder __getitem__ pour accéder aux éléments de la liste.
# src/python/article/dunder_example.py
def get_list():
return [1, 2, 3, 4, 5]
Class Article.DunderExample Extends %RegisteredObject
{
ClassMethod Run()
{
Set sys = ##class(%SYS.Python).Import("sys")
do sys.path.append("/irisdev/app/src/python/article")
set dunderExample = ##class(%SYS.Python).Import("dunder_example")
set myList = dunderExample."get_list"()
for i=0:1:myList."__len__"()-1 {
write myList."__getitem__"(i), !
}
}
}
Lançons-la:
iris session iris -U IRISAPP '##class(Article.DunderExample).Run()'
Le résultat sera le suivant:
1
2
3
4
5
Cela montre comment utiliser les méthodes dunder pour interagir avec des objets Python dans un contexte IRIS, ce qui vous permet de tirer parti des capacités de Python tout en travaillant dans l'environnement ObjectScript.
Une bonne utilisation de dunder consisterait à placer à la fin de votre script Python un bloc if __name__ == " __main__ ": afin d'empêcher l'exécution du code lorsque le script est importé en tant que module.
Rappelez-vous, le premier article expliquait que lorsque vous importiez un script, le code y était exécuté. Ce bloc vous permet de définir du code qui ne doit s'exécuter que lorsque le script est exécuté directement, et non lorsqu'il est importé.
Exemple:
# src/python/article/dunder_example.py
def get_list():
return [1, 2, 3, 4, 5]
if __name__ == "__main__":
print(get_list())
Ce que vous pouvez faire en Python, même avec son sucre syntaxique, vous pouvez le faire en ObjectScript avec les méthodes dunder.
Si vous souhaitez générer une erreur personnalisée arbitraire dans un bloc TRY, vous pouvez transmettre une exception avec un throw comme suit. Dans l'exemple suivant, une erreur personnalisée est générée si Stcount est inférieur à 1.
Les modules, quel sujet ! Nous n'avons pas de notion équivalente en ObjectScript, mais c'est un concept fondamental en Python. Découvrons-le ensemble.
Je considère les modules comme une couche intermédiaire entre les classes et les packages. Voici un exemple.
Un mauvais exemple :
# MyClass.py
class MyClass:
def my_method(self):
print("Hello from MyClass!")
Lorsque vous voulez utiliser cette classe dans un autre script, vous devez faire comme suit:
# class_usage.py
from MyClass import MyClass # weird, right?
my_instance = MyClass()
my_instance.my_method()
En quoi cet exemple est-il mauvais?
Tout d'abord, parce que les noms de fichiers doivent être écrits en snake_case conformément à la norme PEP 8, et qu'ils doivent donc être nommés my_class.py.
Ensuite, parce que vous importez une classe à partir d'un fichier qui porte le même nom que la classe. Ce n'est pas une bonne pratique en Python.
Je sais que cela peut être déroutant, surtout si vous venez d'ObjectScript où les classes sont définies dans des fichiers portant le même nom que celui de la classe.
Donc, nous venons de voir que les modules peuvent être des fichiers Python, mais sans l'extension .py.
Mais attendez, cela signifie-t-il qu'un script python est également un module? Oui, tout à fait!
C'est pourquoi il faut être prudent lorsque vous importez un script, car celui-ci exécutera le code qui y est contenu. Consultez l'article Introduction à Python pour en savoir plus.
__init__.pyComment ça, un dossier peut être un module? Oui, c'est possible!
Un dossier peut être un module s'il contient un fichier __init__.py. Ce fichier peut être vide ou contenir le code d'initialisation du module.
Voici un exemple:
src/python/article/
└── my_folder_module/
├── __init__.py
├── my_sub_module.py
└── another_sub_module.py
# my_folder_module/my_sub_module.py
class MySubModule:
def my_method(self):
print("Hello from MySubModule!")
# my_folder_module/another_sub_module.py
class AnotherSubModule:
def another_method(self):
print("Hello from AnotherSubModule!")
# my_folder_module/__init__.py
# Ce fichier peut être vide ou contenir le code d'initialisation du module.
Dans ce cas, my_folder_module est un module, et vous pouvez l'importer comme suit:
from my_folder_module import my_sub_module, another_sub_module
Ou si vous définissez un fichier __init__.py avec le contenu suivant:
# my_folder_module/__init__.py
from .my_sub_module import MySubModule
from .another_sub_module import AnotherSubModule
Vous pouvez l'importer de la manière suivante:
from my_folder_module import MySubModule, AnotherSubModule
Vous voyez la subtilité ? Vous pouvez importer les classes directement depuis le module sans spécifier le sous-module, car le fichier __init__.py est exécuté lorsque vous importez le module, et ce fichier peut définir les éléments disponibles dans l'espace de noms du module.
Lorsque vous importez un module, Python le recherche dans les répertoires spécifiés dans le fichier sys.path. Il s'agit d'une liste de chaînes de caractères qui spécifie le chemin de recherche des modules.
Vous pouvez afficher le sys.path actuel en exécutant le code suivant:
import sys
print(sys.path)
Par défaut, le répertoire actuel ainsi que d'autres répertoires variés en fonction de votre installation Python sont inclus.
Vous pouvez également ajouter des répertoires à sys.path lors de l'exécution, ce qui est utile lorsque vous souhaitez importer des modules à partir d'un emplacement spécifique. Par exemple:
import sys
sys.path.append('/path/to/your/module')
from your_module import YourClass
Pour cette raison, dans l'article précédent, nous avons ajouté le chemin d'accès au module avant de l'importer:
Set sys = ##class(%SYS.Python).Import("sys")
do sys.path.append("/irisdev/app/src/python/article")
set my_module = ##class(%SYS.Python).Import("my_module")
Quels sont les autres répertoires dans sys.path? Il s'agit généralement des répertoires suivants:
Voici comment fonctionne site-packages. Lorsque vous installez un package à l'aide de pip, il est installé dans le répertoire site-packages, qui est automatiquement inclus dans sys.path. Cela vous permet d'importer le package sans avoir à spécifier son emplacement.
🤨🔍 Mais comment et où le répertoire site-packages est-il défini, et par qui?
Le répertoire site-packages est créé lors de l'installation de Python et se trouve généralement dans le répertoire lib de votre installation Python. Son emplacement exact dépend de votre système opérationnel et de la manière dont Python a été installé.
Par exemple, sur une installation Linux classique, le répertoire site-packages peut être accessible à l'emplacement suivant:
/usr/local/lib/python3.x/site-packages
Sous Windows, il peut se trouver à l'emplacement suivant:
C:\Python3x\Lib\site-packages
Lorsque vous installez un package à l'aide de pip, il est installé dans le répertoire site-packages, qui est automatiquement inclus dans sys.path. Cela vous permet d'importer le package sans avoir à spécifier son emplacement.
import site
print(site.getsitepackages())
🤨🔍 A quel moment et à quel endroit l'interpréteur Python lit-il le fichier site.py?
Le fichier site.py (qui se trouve dans le répertoire standard de la bibliothèque) est exécuté automatiquement au lancement de l'interpréteur Python. Il est responsable de la configuration du répertoire site-packages et de son ajout à sys.path. Ce fichier se trouve dans le répertoire standard de la bibliothèque de votre installation Python.
Dans IRIS, nous avons également un fichier site.py, qui se trouve dans <installation_directory>/lib/python/iris_site.py. Ce fichier est exécuté lorsque vous démarrez ou importez un script/module dans IRIS, et il configure le sys.path pour vous.
En résumé, le fichier iris_site.py effectue les opérations suivantes:
site-packages par défaut<installation_directory>/lib/python/ à sys.path<installation_directory>/mgr/python/ à sys.pathsys.pathUn module peut être:
.py)__init__.pysys.pathSalut tout le monde !
Parfois, lorsqu’on conçoit une méthode de classe et qu’on y ajoute de plus en plus de fonctionnalités utiles, le nombre de paramètres peut rapidement atteindre 10, voire plus.
Cela devient alors assez difficile pour les utilisateurs de ces méthodes utiles de se rappeler de la position des paramètres importants, et il devient très facile de se tromper en inversant des valeurs entre paramètres.
Voici un exemple d’une telle méthode (j’ai demandé à GPT de me créer une méthode avec 20 paramètres) :
ClassMethod GenerateReportWith20Params(
pTitle As%String = "",
pAuthor As%String = "",
pDate As%String = "", // ex. 2025-09-03
pCompany As%String = "",
pDepartment As%String = "",
pVersion As%String = "1.0",
pFormat As%String = "pdf", // pdf|html|docx
pIncludeCharts As%Boolean = 1,
pIncludeSummary As%Boolean = 1,
pIncludeAppendix As%Boolean = 0,
pConfidentiality As%String = "Public",
pLanguage As%String = "en",
pReviewers As%String = "", // CSV, ex. "Alice,Bob"
pApprover As%String = "",
pLogoPath As%String = "",
pWatermarkText As%String = "",
pColorScheme As%String = "default",
pPageSize As%String = "A4",
pOrientation As%String = "Portrait",
pOutputPath As%String = "report.pdf"
) As%Status
{
// implémentation
}
Ce court article traite du PEP 8, le guide de style Python.
En bref, le PEP 8 fournit des directives et des bonnes pratiques pour écrire du code Python.
snake_caseCamelCasesnake_caseUPPER_CASEInutile de tout citer, mais gardez bien à l'esprit que cela vous aidera à comprendre le code de vos collègues et permettra à ces derniers de comprendre le vôtre ^^.
Vous avez peut-être déjà entendu parler du terme pythonic. Suivre les recommandations du PEP 8 est un moyen d'écrire du code Python considéré comme pythonique (ce n'est pas la seule méthode, mais cela en fait partie).
Dans IRIS, et en particulier dans ObjectScript, nous avons également un guide de style, qui repose principalement sur le camelCase pour les noms de variables et le PascalCase pour les noms de classes.
Malheureusement, PEP 8 recommande d'utiliser le snake_case pour les noms de variables et de fonctions.
Et comme vous le savez déjà, dans ObjectScript, le trait de soulignement (_) sert à la concaténation et ne nous convient évidemment pas.
Comment contourner ce problème ? Utilisez des guillemets doubles pour appeler les noms de variables/fonctions Python dans le code ObjectScript.
Exemple:
Class Article.PEP8Example Extends %RegisteredObject
{
ClassMethod Run()
{
Set sys = ##class(%SYS.Python).Import("sys")
do sys.path.append("/irisdev/app/src/python/article")
set pep8Example = ##class(%SYS.Python).Import("pep8_example")
do pep8Example."my_function"() // Observez les guillemets doubles autour du nom de la fonction
}
}
Cette commande appellera la fonction my_function dans le fichier pep8_example.py, qui est définie comme suit:
# src/python/article/pep8_example.py
def my_function():
print("Hello, World!")
Lorsque vous exécutez la méthode Run de la classe Article.PEP8Example, le résultat suivant s'affiche:
iris session iris -U IRISAPP '##class(Article.PEP8Example).Run()'
Hello, World!
Ça y est!
Cet article présente une introduction à la programmation Python dans le contexte d'IRIS.
Avant toute chose, je vais aborder un sujet important : Fonctionnement de Python. Cela vous aidera à comprendre certains problèmes et certaines limites que vous pourriez rencontrer lorsque vous utilisez Python dans IRIS.
Tous les articles et exemples sont disponibles dans ce dépôt git: iris-python-article
Python est un langage interprété, ce qui signifie que le code est exécuté ligne par ligne lors de l'exécution, même lorsque vous importez un script.
Qu'est-ce que cela veut dire? Examinons le code suivant:
# introduction.py
def my_function():
print("Hello, World!")
my_function()
Lorsque vous exécutez ce script, l'interpréteur Python lit le code ligne par ligne. Il définit d'abord la fonction my_function, puis appelle cette fonction, qui affiche "Hello, World!" à la console.
Exemple d'exécution directe du script:
python3 /irisdev/app/src/python/article/introduction.py
Cela donnera le résultat suivant:
Hello, World!
Dans un contexte IRIS, que se passera-t-il si nous importons ce script ?
Class Article.Introduction Extends %RegisteredObject
{
ClassMethod Run()
{
Set sys = ##class(%SYS.Python).Import("sys")
do sys.path.append("/irisdev/app/src/python/article")
do ##class(%SYS.Python).Import("introduction")
}
}
Lançons-le:
iris session iris -U IRISAPP '##class(Article.Introduction).Run()'
Cela donnera le résultat suivant:
Hello, World!
En effet, l'interpréteur Python importe le code en l'interprétant, il définit d'abord la fonction, puis l'appelle, exactement comme si vous exécutiez le script directement mais vous ne l'exécutez pas, vous l'importez.
⚠️ Remarque importante : si vous importez le script sans appeler la fonction, rien ne se passera. La fonction est définie, mais elle ne s'exécutera pas jusqu'à ce que vous l'appeliez explicitement.
Compris? L'interpréteur Python exécute le code dans le fichier, et si vous n'appelez pas la fonction, elle ne s'exécutera pas.
Exemple d'importation sans appel:
# introduction1.py
def my_function():
print("Hello, World!")
Lançons-le dans un interpréteur Python:
python3 /irisdev/app/src/python/article/introduction1.py
Résultat:
# Aucun résultat, puisque la fonction est définie mais n'est pas appelée
Dans un contexte IRIS, si vous importez ce script:
Class Article.Introduction1 Extends %RegisteredObject
{
ClassMethod Run()
{
Set sys = ##class(%SYS.Python).Import("sys")
do sys.path.append("/irisdev/app/src/python/article")
do ##class(%SYS.Python).Import("introduction1")
}
}
Lançons-le:
iris session iris -U IRISAPP '##class(Article.Introduction1).Run()'
Vous ne verrez aucun résultat,puisque la fonction est définie mais n'est pas appelée.
🤯 Pourquoi cette nuance est-elle importante?
Lorsque vous importez un script Python, l'interpréteur Python met en cache le script importé. Cela signifie que si vous importez à nouveau le même script, il ne réexécutera pas le code de ce script, mais utilisera la version mise en cache.
Exemple:
Réutilisons le script introduction.py:
# introduction.py
def my_function():
print("Hello, World!")
my_function()
Maintenant, faisons la même chose en réutilisant la classe Article.Introduction:
Class Article.Introduction Extends %RegisteredObject
{
ClassMethod Run()
{
Set sys = ##class(%SYS.Python).Import("sys")
do sys.path.append("/irisdev/app/src/python/article")
do ##class(%SYS.Python).Import("introduction")
}
}
Mais maintenant, nous allons l'exécuter deux fois de suite dans la même session IRIS:
iris session iris -U IRISAPP
IRISAPP>do ##class(Article.Introduction).Run()
Hello, World!
IRISAPP>do ##class(Article.Introduction).Run()
IRISAPP>
🤯 Mais qu'est-ce que c'est que ça ?
Oui, Hello, World! n'est imprimé qu'une seule fois !
⚠️ Votre script importé est mis en cache. Cela signifie que si vous modifiez le script après l'avoir importé, les modifications ne seront pas prises en compte tant que vous n'aurez pas modifié la session IRIS.
Cela vaut également si vous utilisez la balise de langage python language tag dans IRIS:
Class Article.Introduction2 Extends %RegisteredObject
{
ClassMethod Run() [ Language = python ]
{
import os
if not hasattr(os, 'foo'):
os.foo = "bar"
else:
print("os.foo already exists:", os.foo)
}
}
Lançons-le:
iris session iris -U IRISAPP
IRISAPP>do ##class(Article.Introduction2).Run()
IRISAPP>do ##class(Article.Introduction2).Run()
os.foo already exists: bar
Oh non, le module os est mis en cache et l'attribut foo n'est pas redéfini comme inexistant.
J'espère que cette introduction sera utile pour comprendre pourquoi, lorsque vous travaillez avec Python dans IRIS, vous pouvez rencontrer des comportements inattendus, notamment lors de l'importation de scripts et de la mise en cache.
À retenir lorsque vous travaillez avec Python dans IRIS:
Attendez! C'est illogique, si vous dites que lorsque vous importez un script, il est mis en cache. Pourquoi, lorsque je travaille avec la balise language tag = python, lorsque je modifie le script, cela fonctionne sans changer la session IRIS?
Bonne question, cela est dû au fait que la balise language tag est conçue pour que, chaque fois que vous l'exécutez, elle relise le script et l'exécute ligne par ligne comme s'il s'agissait de nouvelles lignes dans un interpréteur Python natif. La balise language tag n'importe pas le script, elle l'exécute simplement comme si vous l'exécutiez directement dans un interpréteur Python sans le relancer.
Exemple:
Class Article.Introduction2 Extends %RegisteredObject
{
ClassMethod Run() [ Language = python ]
{
import os
if not hasattr(os, 'foo'):
os.foo = "bar"
else:
print("os.foo already exists:", os.foo)
}
}
Lançons-le:
iris session iris -U IRISAPP
IRISAPP>do ##class(Article.Introduction2).Run()
IRISAPP>do ##class(Article.Introduction2).Run()
os.foo already exists: bar
Dans un interpréteur Python, cela se présentera comme suit:
import os
if not hasattr(os, 'foo'):
os.foo = "bar"
else:
print("os.foo already exists:", os.foo)
import os
if not hasattr(os, 'foo'):
os.foo = "bar"
else:
print("os.foo already exists:", os.foo)
Résultat:
os.foo already exists: bar # only printed once
Maintenant, c'est clair?
Cet excellent article a récemment déclenché une discussion privée, et j'aimerais partager certaines de mes réflexions à ce sujet.
La question motivante se résume ainsi : pourquoi devons-nous absolument établir des règles ou des conventions de codage ? Où est passée la merveilleuse époque des artistes-programmeurs de la Renaissance qui traçaient leur propre voie, avant d'être supplantés par les artisans, puis (pire encore) par IA?
En bref, il existe plusieurs raisons pour expliquer l'utilité des normes et des directives de codage, et les artistes-programmeurs de la Renaissance n'ont pas complètement disparu.
Raison 1: De nos jours, lorsque vous enseignez à un artiste, à un peintre débutant, vous commencez par lui demander de colorier à l'intérieur des lignes. Ce peintre sera peut-être brillant un jour, mais pas encore. Si vous voulez apprendre à créer des œuvres d'art, vous devez d'abord faire cela, puis apprendre progressivement les techniques et les concepts des maîtres. Ensuite, si vous êtes vraiment doué ou si vous avez beaucoup de chance, vous pourrez développer votre propre style et créer quelque chose de nouveau que le reste du monde voudra imiter. Mais vous devez commencer par suivre les règles.
(remarque: j'ai trouvé cela sur l'Internet ; aucun de mes enfants ne sait encore faire ça.)
Raison 2: Si vous travaillez dans un domaine où votre créativité doit s'intégrer à celle des autres, comme dans un ouvrage de patchwork, vous devez établir certaines règles, sans quoi votre œuvre ne fonctionnera pas, car les pièces ne s'emboîteront jamais. Vous pouvez soit convenir du principe selon lequel "nous faisons tous des carrés de 40 cm", soit travailler encore plus étroitement et en collaboration avec un groupe d'autres personnes, ce qui n'est peut-être pas la meilleure option pour un artiste solitaire qui passe quatre ans à peindre un plafond. (Surtout si ses responsables décident de faire appel à quelques autres artistes solitaires pour "l'aider.”)
(C'est ChatGPT qui m'a inspiré cette image. Toutes mes excuses aux artistes réels.)
Raison 3: Si vous travaillez sur un élément de codage existant, particulièrement ancien ou particulièrement génial, vous êtes souvent confronté à un dilemme : comprendre et accepter l'intention et l'élégance de la conception et de l'exécution de l'auteur , ou simplement dire "C'est moi le responsable maintenant, on va tout jeter et faire à ma façon." Je vais vous donner un exemple : une application web sur laquelle j'ai travaillé se sert beaucoup de "pages XML" où un trio (pageName.xml, pageName.js, pageName.mac) forme une page. Le fichier pageName.xml était, jusqu'à récemment, probablement écrit dans cet étrange dialecte "WD-xsl" qui ressemble beaucoup au XSLT standard mais qui ne fonctionne que dans Internet Explorer Microsoft Edge s'il se fait passer pour IE5. Le fichier pageName.js contient probablement environ 40 fois plus de "frame" que nécessaire et comfortable. Le fichier pageName.mac est probablement rempli de syntaxe à points, de commandes abrégées et de macros incohérentes. Si vous êtes un développeur débutant, vous pleurez et vous fuyez parce que cela n'a aucun sens. Si vous êtes un développeur expérimenté, vous lisez le code, vous essayez de le comprendre, puis vous décidez que “c'est dégoûtant, je vais faire mieux autrement” – mais alors la personne qui travaillera ensuite sur l'application devra apprendre le paradigme original et votre nouveau paradigme astucieux. Faites cela pendant 20 ans, et un véritable cauchemar vous attend. Mais si vous êtes vraiment un artiste expert, vous pouvez vous lancer dans la restauration artistique: observez l'élégance de la structure d'origine et travaillez en respectant celle-ci, en corrigeant délicatement les éléments architecturaux sans importance qui font pleurer le nouveau développeur et poussent le développeur senior à appuyer sur "Supprimer" sans risquer de créer un chaos fragmenté ou de passer des années à tout repeindre. Peut-être même réaliserez-vous vos propres œuvres dans le style du grand maître. La leçon la plus importante à tirer de ce conte est qu'en tant qu'artiste véritable, vous êtes tout à fait intéressé à produire un travail d'une telle qualité que quelqu'un qui en hériterait sans passer des années pour s'entraîner ne déciderait pas de tout jeter. Les "petites choses" comme le style de code, la lisibilité et la gestion de la dette technique contribuent grandement à préserver l'architecture et même chaque ligne de code.
En bref:
InterSystems a le plaisir d'annoncer la sortie de la version 3.0.5 de l'extension VS Code - ObjectScript. Cette version inclut de nombreuses corrections de bugs, ainsi que des modifications des données de télémétrie collectées. La collecte de données d'utilisation supplémentaires permet à InterSystems d'identifier et de prioriser les correctifs et améliorations les plus bénéfiques pour vous, nos utilisateurs. Les informations personnelles identifiables (PII) ne seront jamais collectées et la télémétrie peut être désactivée via le paramètre telemetry.telemetryLevel. La liste complète des
Si vous migrez d'Oracle vers InterSystems IRIS, comme beaucoup de mes clients, vous risquez de rencontrer des modèles SQL spécifiques à Oracle nécessitant une conversion.
Prenons l'exemple suivant:
SELECT (TO_DATE('2023-05-12','YYYY-MM-DD') - LEVEL + 1) AS gap_date
FROM dual
CONNECT BY LEVEL <= (TO_DATE('2023-05-12','YYYY-MM-DD') - TO_DATE('2023-05-02','YYYY-MM-DD') + 1);
Dans Oracle:
LEVEL est une pseudo-colonne utilisée dans les requêtes hiérarchiques (CONNECT BY). Elle commence à 1 et s'incrémente de 1.CONNECT BY LEVEL <= (...) détermine le nombre de lignes à générer.11, donc la requête génère 11 lignes, en comptant à rebours à partir du 12 mai 2023 jusqu'au 2 mai 2023.Répartition du résultat:
LEVEL = 1 → 2023-05-12
LEVEL = 2 → 2023-05-11
...
LEVEL = 11 → 2023-05-02
La question est maintenant de savoir comment obtenir ce résultat dans InterSystems IRIS, qui ne prend pas en charge CONNECT BY?
Une solution consiste à implémenter une requête de type SQL à l'aide d'ObjectScript qui imite ce comportement. Vous trouverez ci-dessous un exemple de définition CREATE QUERY qui accepte une date de début STARTDATE et un nombre de jours DAYS, et renvoie la liste des dates par ordre descendant.
CREATE QUERY GET_GAP_DATE(IN STARTDATE DATE, IN DAYS INT)
RESULTS (GAP_DATE DATE)
PROCEDURE
LANGUAGE OBJECTSCRIPT
Execute(INOUT QHandle BINARY(255), IN STARTDATE DATE, IN DAYS INT)
{
SET QHandle("start") = STARTDATE
SET QHandle("days") = DAYS
SET QHandle("level") = 1
RETURN $$$OK
}
Fetch(INOUT QHandle BINARY(255), INOUT Row %List, INOUT AtEnd INT)
{
IF (QHandle("level") > QHandle("days")) {
SET Row = ""
SET AtEnd = 1
} ELSE {
SET Row = $ListBuild(QHandle("start") - QHandle("level") + 1)
SET QHandle("level") = QHandle("level") + 1
}
RETURN $$$OK
}
Close(INOUT QHandle BINARY(255))
{
KILL QHandle
QUIT $$$OK
}
Vous pouvez exécuter la commande CREATE QUERY Vous pouvez exécuter la commande CREATE QUERY ci-dessus dans le portail IRIS System Management, ou via un outil tel que DBeaver ou un éditeur Python/Jupyter Notebook utilisant JDBC/ODBC.
Pour générer le même résultat que la requête Oracle ci-dessus, utilisez:
SELECT * FROM GET_GAP_DATE(
TO_DATE('2023-05-12', 'YYYY-MM-DD'),
TO_DATE('2023-05-12', 'YYYY-MM-DD') - TO_DATE('2023-05-02', 'YYYY-MM-DD') + 1
);
Cela donnera le résultat suivant:
GAP_DATE
----------
2023-05-12
2023-05-11
...
2023-05-02
(11 rows)
Vous pouvez également utiliser cette requête comme sous-requête ou dans des jointures:
SELECT *
FROM GET_GAP_DATE(TO_DATE('2023-05-12', 'YYYY-MM-DD'), 11)
CROSS JOIN dual;
Cela vous permet d'intégrer des plages de dates dans des flux SQL plus importants.
J'espère que cela sera utile à tous ceux qui sont confrontés à des scénarios de migration d'Oracle vers IRIS ! Si vous avez mis au point des solutions alternatives ou si vous proposez des améliorations, n'hésitez pas à me faire part de vos commentaires.
J'écris cet article principalement pour recueillir un consensus informel sur la façon dont les développeurs utilisent Python avec IRIS. N'hésitez donc pas à répondre au sondage à la fin de cet article ! Dans le corps de l'article, je détaillerai chaque choix proposé, ainsi que ses avantages, mais n'hésitez pas à le parcourir et à simplement répondre au sondage.
Le bon vieux temps
La classe %Library.DynamicObject existe dans IRIS depuis bien avant que IRIS ne devienne IRIS. Si vous l'utilisez depuis l'époque de Cache, vous souhaiterez peut-être vous familiariser avec certaines de ses modifications.
Dans Cache 2018, la méthode %Get n'avait qu'un seul argument. Il s'agissait de la clé permettant de récupérer les données dans le JSON. Ainsi, si votre objet JSON s'appelait myObj, cela ressemblerait à ceci:
{
“mybool”:true,
“mynum”:1234,
“mystring”:”Hello World!”
}L'exploitation de myObj.%Get(“mybool”) renverrait 1, myObj.%Get(“mynum”) renverrait 1234 et myObj.%Get("mystring") renverrait la chaîne "Hello World!"
La définition de ces paramètres, en revanche, nécessitait un peu plus de travail. Par exemple, l'attribution d'une propriété JSON à 0 pouvait signifier le nombre 0, une valeur booléenne signifiant faux ou une chaîne littérale "0". C'est pourquoi la méthode %Set avait toujours un troisième argument facultatif. Pour créer l'objet JSON mentionné ci-dessus, nous pouvions utiliser le code suivant:
set myObj = ##class(%Library.DynamicObject).%New()
do myObj.%Set(“mybool”,1,”boolean”)
do myObj.%Set(“mynum”,1234,”number”)
do myObj.%Set(“mystring”,”Hello World!”,”string”)Cependant, dans ce cas, nous pourrions également omettre le troisième argument des deux derniers. Ainsi, 1234 serait reconnu comme un nombre, car il n'est pas entre guillemets, tandis que "Hello World!" serait identifié comme une chaîne, car il est entre guillemets. Si nous voulions ajouter la valeur 1234 à l'objet en tant que chaîne, nous pourrions changer la chaîne en nombre. Nous pourrions également spécifier le type "null". Dans ce cas, la valeur doit être "". En pratique, cependant, nous ajoutons souvent ces valeurs à partir de variables dans notre code ObjectScript. Pour cette raison, il peut être préférable de spécifier cet argument, juste au cas où la variable serait une chaîne ou un nombre, afin de garantir que notre JSON arrive à destination correctement encodé.
Comment j'ai appris à ne plus m'inquiéter à propos de <MAXSTRING> et aimer JSON
Comme l'a dit un jour le sage Billy Joel, ""Le bon vieux temps n'était pas toujours bon, demain n'est pas aussi mauvais qu'il n'y paraît." La liste des types pour %Set s'est allongée, et la méthode %Get a acquis deux nouveaux arguments. Ce qui est crucial, c'est qu'elles prennent toutes deux en charge le type "stream". Si vous avez déjà traité de grandes quantités de données JSON, vous avez probablement déjà rencontré une erreur
try{
Set mydata = myObj.%Get(“mydata”,”N/A”)
}
catch ex{
if ex.Name = “<MAXSTRING>”{
set mydata = myObj.%Get(“mydata”,,”stream”)
}
}Il tentera de définir mydata à la valeur située à l'intérieur de "mydata" dans l'objet JSON. Si cet élément n'existe pas, il renverra "N/A" à la place. Si cet élément est trop long pour une chaîne, le système lèvera une exception vers le bloc catch. Nous devons vérifier le nom de cette exception, car si une exception différente s'est produite, il ne serait pas logique d'essayer d'obtenir les données sous forme de flux. Vous pouvez en savoir plus sur la gestion des exceptions ici. Si la valeur est
Si vous suivez l'approche décrite ci-dessus, vous ne saurez pas si mydata dans le code est une chaîne ou un flux. Cela signifie que vous devrez suivre le code similaire à celui ci-dessous:
if$ISOBJECT(mydata){
//Traitement des flux ici
}
else{
//Traitement des chaînes ici
}Vous pouvez également utiliser l'option stream chaque fois afin de vous assurer que vous avez toujours un flux à votre disposition. Cependant, cela entraînerait une utilisation inutile des ressources et alourdirait votre code.
Une autre option consiste à ajouter un flux à un objet dynamique à l'aide de %Set. Consultez l'exemple suivant:
set mystream = ##class(%Stream.FileBinary).%New()
do mystream.LinkToFile(“/path/to/your/file”)
do myObj.%Set(“mydata”,mystream,”stream”)Les données de votre fichier seront désormais enregistrées dans le champ mydata de votre objet dynamique.
%Set et %Get encodent et décodent également les chaînes à l'aide de l'encodage Base64.
Gardez toujours à l'esprit que l'encodage Base64 est un encodage et non un cryptage ! Il n'y a pas de clés secrètes ni de mots de passe pour décoder votre message, et il est facilement réversible. Par conséquent, vous devez toujours utiliser un protocole crypté, tel que TLS ou HTTPS, pour la transmission ! Base64 est utilisé pour transmettre des caractères non ASCII de manière à ce que les systèmes ASCII puissent les recevoir et les transmettre.
Maintenant que cette remarque importante est faite, nous pouvons enfin voir comment cela fonctionne. Si nous apportons une petite modification à l'exemple de code précédent, le contenu du flux de fichiers sera encodé en Base64.
set mystream = ##class(%Stream.FileBinary).%New()
do mystream.LinkToFile(“/path/to/your/file”)
do myObj.%Set(“mydata”,mystream,”stream>base64”)D'autre part, si les données du fichier étaient déjà encodées en Base64 et que nous voulions les convertir en données décodées, il suffirait de changer un seul caractère.
set mystream = ##class(%Stream.FileBinary).%New()
do mystream.LinkToFile(“/path/to/your/file”)
do myObj.%Set(“mydata”,mystream,”stream<base64”)Les signes " supérieur à" ou "inférieur à" indiquent toujours la direction dans laquelle la conversion a lieu. Si nous convertissons un flux non codé en une chaîne Base64, le signe pointera vers Base64. Si nous convertissons un flux codé en Base64 en un flux non codé, le signe pointera de Base64 vers le flux. La même fonctionnalité existe pour les chaînes lorsque string>base64 et string
set something = myObj.%Get(“something”,”NA”,”string>base64”)Si l'élément "quelque chose" existe, il sera renvoyé sous sa forme encodée en Base64. Cependant, s'il n'existe pas, "NA" sera renvoyé sans être encodé.
Il existe une restriction concernant l'option d'encodage Base64. Seuls les caractères dont le code est compris entre 0 et 255 peuvent être encodés en Base64. Les codes de caractères supérieurs à 255 entraîneront une exception <WIDE CHAR>. FPar exemple, la ligne suivante provoquera une telle exception:
set mychar = $C(256)
do myobj.%Set(“mychar”,mychar,”string>base64”)Alors, j'ai entendu dire que vous aimiez JSON . . .
Parfois, il y a du JSON à l'intérieur de votre JSON. La manière par défaut de gérer cette situation est généralement celle que vous choisiriez. Cependant, une autre option a été ajoutée à l'argument de type pour traiter un cas d'utilisation différent. Il s'agit du type "json". Regardez l'objet JSON suivant:
{
“mystring”:”Hello World!”,
“mynumber”:1234,
“myjson”:{
“subitem1”:”Hello Mars!”,
“subitem2”:”Hello Stars!”
}
}En règle générale, lorsque vous rencontrez ce problème, vous devez utiliser la méthode %Get avec la clé « myjson » pour obtenir un objet dynamique. Voici un exemple:
set myjson = myobj.%Get(“myjson”)
write myjson.%Get(“subitem1”)La ligne ci-dessus écrirait "Hello Mars!". C'est le cas le plus courant dans cette situation. Cependant, dans certains cas, vous préférerez peut-être obtenir le JSON réel contenu dans cet élément sous forme de chaîne. Dans ce cas, vous pouvez procéder comme suit:
set myjson = myobj.%Get(“myjson”,,”json”)
write myjsonLa chaîne JSON sera écrite exactement telle qu'elle est:
{“subitem1”:”Hello Mars!”,”subitem2”:”Hello Stars!”}Cela peut s'avérer utile dans les cas où nous voulons transmettre le JSON tel quel à un autre processus. Notez que, contrairement à tous les autres types nouveaux, celui-ci n'est pris en charge que pour la méthode %Get, et non pour la méthode %Set.
Hourra, hourra, les massives!
Jusqu'à présent, nous avons discuté de ces nouveaux objets dans le contexte de la classe %Library.DynamicObject, mais ils sont également pris en charge pour la classe %Library.DynamicArray. Dans cette classe, %Set et %Get prennent en charge les mêmes arguments de type que dans la classe %Library.DynamicObject. La classe de tableaux dynamiques dispose toutefois d'une méthode %Push supplémentaire. Elle prend en charge les mêmes types que %Set, à l'exception du type JSON.
Sans plus attendre, c'est probablement le bon moment pour revoir vos anciens codes et implémenter ces changements à votre avantage!
J'ai un nouveau projet qui consiste à stocker des informations provenant de réponses REST dans une base de données IRIS. Il me faudra synchroniser les informations provenant d'au moins deux douzaines de points de terminaison REST distincts, ce qui implique la création de presque autant de classes ObjectScript pour stocker les résultats de ces points de terminaison.
Puis-je utiliser ChatGPT pour créer ces classes? La réponse est "Oui", ce qui est génial puisqu'il s'agit de ma première tentative d'utiliser l'IA générative pour quelque chose d'utile. En effet, générer des images de girafes mangeant de la soupe devenait un peu vieux….
Voici ce que j'ai fait:
J'ai placé la demande suivante dans la fenêtre de message de ChatGPT:
Moi: Générer une classe ObjectScript qui contiendra les données du JSON suivant:
J'ai appuyé sur "Return" avant d'entrer le JSON et ChatGPT m'a donc dirigé comme suit:
ChatGPT: Veuillez fournir la structure JSON pour laquelle vous souhaitez que je génère la classe ObjectScript. Si vous avez un exemple d'objet JSON, collez-le ici et je créerai pour vous la classe ObjectScript InterSystems correspondante.
J'ai saisi ce qui suit dans la fenêtre de message:
{
"id": 335818632,
"appId": 113,
"appName": "Batch",
"contentId": 182455380233,
"subject": "Test Subject",
"name": "Test email campaign name",
"counters": {
"processed": 3910,
"deferred": 86,
"unsubscribed": 17,
"statuschange": 17,
"bounce": 153,
"mta_dropped": 8,
"dropped": 299,
"delivered": 3749,
"sent": 3903,
"click": 16,
"open": 323
},
"lastProcessingFinishedAt": 1733232499000,
"lastProcessingStartedAt": 1733232303000,
"lastProcessingStateChangeAt": 1733232499000,
"numIncluded": 4201,
"processingState": "DONE",
"scheduledAt": 1733232300000,
"type": "BATCH_EMAIL"
}
Réponse de ChatGPT:
Voici la classe ObjectScript InterSystems qui correspond à la structure JSON fournie:
Class MyNamespace.MyJSONData Extends (%Persistent, %JSON.Adaptor)
{
Property id As%Integer;Property appId As%Integer;Property appName As%String;Property contentId As%Integer;Property subject As%String;Property name As%String;Property counters As MyNamespace.Counters;Property lastProcessingFinishedAt As%BigInt;Property lastProcessingStartedAt As%BigInt;Property lastProcessingStateChangeAt As%BigInt;Property numIncluded As%Integer;Property processingState As%String;Property scheduledAt As%BigInt;Property type As%String;ClassMethod%OnJSONImport(jsonObject As%Object, instance As MyNamespace.MyJSONData) As%Status
{
Quit ..%JSONImport(jsonObject, .instance)
}
}
Class MyNamespace.Counters Extends (%SerialObject, %JSON.Adaptor)
{
Property processed As%Integer;Property deferred As%Integer;Property unsubscribed As%Integer;Property statuschange As%Integer;Property bounce As%Integer;Property mta_dropped As%Integer;Property dropped As%Integer;Property delivered As%Integer;Property sent As%Integer;Property click As%Integer;PropertyopenAs%Integer;
}
Avec une explication:
.png)
Ce code est un bon départ, mais j'aimerais qu'il s'intègre dans mon paquetage nommé “MyPkg” et que la classe porte le nom “EmaiCampaign”. De plus, grâce à mes connaissances en NI, je sais que les valeurs qui ont généré les propriétés “%BigInt” sont en fait des horaires Linux et que les propriétés devraient être %Library.PosixTime”.
Je fais la demande suivante (je ne sais pas trop pourquoi je dis "s'il vous plaît" à une machine; je suppose que mes parents ont fait du bon travail):
Moi: Pouvons-nous recréer la classe, s'il vous plaît, en renommant le paquetage " MyPkg" et la classe "EmailCampaign"? De plus, veuillez changer les types de propriétés de %BigInt à %Library.PosixTime.
Reponse de ChatGPT:
Voici la classe ObjectScript mise à jour avec le nom de paquetage et le nom de classe spécifiés, et les propriétés d'horodatage mises à jour pour l'utilisation de %Library.PosixTime:
Class MyPkg.EmailCampaign Extends (%Persistent, %JSON.Adaptor)
{
Property id As%Integer;Property appId As%Integer;Property appName As%String;Property contentId As%Integer;Property subject As%String;Property name As%String;Property counters As MyPkg.Counters;Property lastProcessingFinishedAt As%Library.PosixTime;Property lastProcessingStartedAt As%Library.PosixTime;Property lastProcessingStateChangeAt As%Library.PosixTime;Property numIncluded As%Integer;Property processingState As%String;Property scheduledAt As%Library.PosixTime;Property type As%String;ClassMethod%OnJSONImport(jsonObject As%Object, instance As MyPkg.EmailCampaign) As%Status
{
Quit ..%JSONImport(jsonObject, .instance)
}
}
Class MyPkg.Counters Extends (%SerialObject, %JSON.Adaptor)
{
Property processed As%Integer;Property deferred As%Integer;Property unsubscribed As%Integer;Property statuschange As%Integer;Property bounce As%Integer;Property mta_dropped As%Integer;Property dropped As%Integer;Property delivered As%Integer;Property sent As%Integer;Property click As%Integer;PropertyopenAs%Integer;
}
Avec une explication suivante:
.png)
Après avoir copié le code "tel quel" dans VSCode, des problèmes de syntaxe avec les accolades ont été mis en évidence. Les classes ObjectScript ne permettent pas de définir des classes internes.
.png)
Demander à ChatGPT de résoudre le problème des « accolades » en faisant de la classe interne MyPkg.Counters une classe séparée est une opération impossible “no-op”; un humain devra déplacer cette classe dans un autre fichier. ChatGPT a renommé cette classe après la demande suivante:
Moi: La classe telle qu'elle est écrite ne compile pas. Pouvons-nous déplacer la classe interne nommée MyPkg.Counters de la classe principale vers sa propre classe et la renommer en MyPkg.CampaignCounters?
Reponse de ChatGPT:
Voici le code ObjectScript mis à jour avec la classe MyPkg.CampaignCounters déplacée comme sa propre classe:
Class MyPkg.EmailCampaign Extends (%Persistent, %JSON.Adaptor)
{
Property id As%Integer;Property appId As%Integer;Property appName As%String;Property contentId As%Integer;Property subject As%String;Property name As%String;Property counters As MyPkg.CampaignCounters;Property lastProcessingFinishedAt As%Library.PosixTime;Property lastProcessingStartedAt As%Library.PosixTime;Property lastProcessingStateChangeAt As%Library.PosixTime;Property numIncluded As%Integer;Property processingState As%String;Property scheduledAt As%Library.PosixTime;Property type As%String;ClassMethod%OnJSONImport(jsonObject As%Object, instance As MyPkg.EmailCampaign) As%Status
{
Quit ..%JSONImport(jsonObject, .instance)
}
}
Class MyPkg.CampaignCounters Extends (%SerialObject, %JSON.Adaptor)
{
Property processed As%Integer;Property deferred As%Integer;Property unsubscribed As%Integer;Property statuschange As%Integer;Property bounce As%Integer;Property mta_dropped As%Integer;Property dropped As%Integer;Property delivered As%Integer;Property sent As%Integer;Property click As%Integer;PropertyopenAs%Integer;
}
Après avoir collé ce qui précède dans VSCode et l'avoir compilé, le compilateur a signalé que le type nommé "%Object" n'existe pas dans ObjectScript. v %JSONImport() de %JSON.Adaptor est flexible:
“L'argument d'entrée est soit JSON en tant que chaîne ou flux, soit une sous-classe de %DynamicAbstractObject.”
Après avoir supprimé la propriété "As %Object" pour le premier paramètre de %OnJSONImport() dans la première classe et avoir séparé les deux classes dans des fichiers distincts, la classe MyPkg.EmailCampaign s'est compilée avec succès. Cependant, la classe MyPkg.CampaignCounters ne s'est pas compilée ; ChatGPT ne sait pas (pour l'instant ?) que l'underscore est un caractère spécial en ObjectScript (l'opérateur de concaténation de chaînes de caractères).
Essayons de le lui enseigner.
Moi: Le caractère underscore "_" est un caractère spécial dans ObjectScript. Veuillez changer les propriétés dont le nom contient un underscore en camel case et supprimer l'underscore.
Reponse de ChatGPT:
Voici le code mis à jour avec les propriétés qui avaient des underscores dans leurs noms convertis en camel case:
Class MyPkg.EmailCampaign Extends (%Persistent, %JSON.Adaptor)
{
Property id As%Integer;Property appId As%Integer;Property appName As%String;Property contentId As%Integer;Property subject As%String;Property name As%String;Property counters As MyPkg.CampaignCounters;Property lastProcessingFinishedAt As%Library.PosixTime;Property lastProcessingStartedAt As%Library.PosixTime;Property lastProcessingStateChangeAt As%Library.PosixTime;Property numIncluded As%Integer;Property processingState As%String;Property scheduledAt As%Library.PosixTime;Property type As%String;ClassMethod%OnJSONImport(jsonObject As%Object, instance As MyPkg.EmailCampaign) As%Status
{
Quit ..%JSONImport(jsonObject, .instance)
}
}
Class MyPkg.CampaignCounters Extends (%SerialObject, %JSON.Adaptor)
{
Property processed As%Integer;Property deferred As%Integer;Property unsubscribed As%Integer;Property statusChange As%Integer;Property bounce As%Integer;Property mtaDropped As%Integer;Property dropped As%Integer;Property delivered As%Integer;Property sent As%Integer;Property click As%Integer;PropertyopenAs%Integer;
}
Avec une explication suivante:
.png)
ChatGPT s'est surpassé et a changé une autre propriété, nommée avec deux mots distincts, en camel case également (statuschange); je garde ce changement puisque d'autres propriétés nommées de la même manière dans la classe principale sont toutes en camel case.
Avec le dernier code généré dans deux fichiers séparés (et en supprimant la définition "As %Object" dans la définition de la méthode %OnJSONImport()), tout le code se compile avec succès.
Ces classes générées sont un excellent point de départ pour ce dont j'ai besoin et je répéterai le processus pour les autres sources de données REST de ce projet, ce qui me permettra d'éviter de nombreuses saisies inutiles.
.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.
Depuis l'introduction d'Embedded Python, il y a toujours eu un doute sur ses performances par rapport à ObjectScript et J'en ai discuté à plusieurs reprises avec @Guillaume Rongier , eh bien, profitant du fait que je faisais une petite application pour capturer les données des concours publics en Espagne et pouvoir effectuer des recherches en utilisant les capacités de VectorSearch, j'ai vu l'opportunité de réaliser un petit test.
Les informations relatives aux concours publics sont fournies mensuellement dans des fichiers XML à partir de cette URL et le format typique des informations d'un concours est le suivant:
Comme vous le voyez, chaque concours a des dimensions considérables et dans chaque fichier, nous pouvons trouver environ 450 concours. Cette dimension ne permet pas d'utiliser une classe d'ObjectScript pour le mappage (on pourrait... mais je ne suis pas prêt à le faire).
Mon idée est de capturer uniquement les champs pertinents pour les recherches ultérieures. Pour ce faire, j'ai créé la classe suivante qui nous servira à stocker les informations capturées:
Class Inquisidor.Object.Licitacion Extends (%Persistent, %XML.Adaptor) [ DdlAllowed ]
{
Property IdLicitacion As%String(MAXLEN = 200);Property Titulo As%String(MAXLEN = 2000);Property URL As%String(MAXLEN = 1000);Property Resumen As%String(MAXLEN = 2000);Property TituloVectorizado As%Vector(DATATYPE = "DECIMAL", LEN = 384);Property Contratante As%String(MAXLEN = 2000);Property URLContratante As%String(MAXLEN = 2000);Property ValorEstimado As%Numeric(STORAGEDEFAULT = "columnar");Property ImporteTotal As%Numeric(STORAGEDEFAULT = "columnar");Property ImporteTotalSinImpuestos As%Numeric(STORAGEDEFAULT = "columnar");Property FechaAdjudicacion As%Date;Property Estado As%String;Property Ganador As%String(MAXLEN = 200);Property ImporteGanador As%Numeric(STORAGEDEFAULT = "columnar");Property ImporteGanadorSinImpuestos As%Numeric(STORAGEDEFAULT = "columnar");Property Clasificacion As%String(MAXLEN = 10);Property Localizacion As%String(MAXLEN = 200);
Index IndexContratante On Contratante;
Index IndexGanador On Ganador;
Index IndexClasificacion On Clasificacion;
Index IndexLocalizacion On Localizacion;
Index IndexIdLicitation On IdLicitacion [ PrimaryKey ];
}
Pour capturer les données à l'aide d'Embedded Python, j'ai utilisé la bibliothèque xml.etree.ElementTree qui nous permet d'extraire les valeurs nœud par nœud. Voici la méthode Python que j'ai utilisée pour le mappage du XML:
Method ReadXML(xmlPath As %String) As %String [ Language = python ]
{
import xml.etree.ElementTree as ET
import iris
import pandas as pd
<span class="hljs-keyword">try</span> :
tree = ET.parse(xmlPath)
root = tree.getroot()
<span class="hljs-keyword">for</span> entry <span class="hljs-keyword">in</span> root.iter(<span class="hljs-string">"{http://www.w3.org/2005/Atom}entry"</span>):
licitacion = {<span class="hljs-string">"titulo"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"resumen"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"idlicitacion"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"url"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"contratante"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"urlcontratante"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"estado"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"valorestimado"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"importetotal"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"importetotalsinimpuestos"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"clasificacion"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"localizacion"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"fechaadjudicacion"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"ganador"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"importeganadorsinimpuestos"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"importeganador"</span>: <span class="hljs-string">""</span>}
<span class="hljs-keyword">for</span> tags <span class="hljs-keyword">in</span> entry:
<span class="hljs-keyword">if</span> tags.tag == <span class="hljs-string">"{http://www.w3.org/2005/Atom}title"</span>:
licitacion[<span class="hljs-string">"titulo"</span>] = tags.text
<span class="hljs-keyword">if</span> tags.tag == <span class="hljs-string">"{http://www.w3.org/2005/Atom}summary"</span>:
licitacion[<span class="hljs-string">"resumen"</span>] = tags.text
<span class="hljs-keyword">if</span> tags.tag == <span class="hljs-string">"{http://www.w3.org/2005/Atom}id"</span>:
licitacion[<span class="hljs-string">"idlicitacion"</span>] = tags.text
<span class="hljs-keyword">if</span> tags.tag == <span class="hljs-string">"{http://www.w3.org/2005/Atom}link"</span>:
licitacion[<span class="hljs-string">"url"</span>] = tags.attrib[<span class="hljs-string">"href"</span>]
<span class="hljs-keyword">if</span> tags.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice-place-ext:schema:xsd:CommonAggregateComponents-2}ContractFolderStatus"</span>:
<span class="hljs-keyword">for</span> detailTags <span class="hljs-keyword">in</span> tags:
<span class="hljs-keyword">if</span> detailTags.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice-place-ext:schema:xsd:CommonAggregateComponents-2}LocatedContractingParty"</span>:
<span class="hljs-keyword">for</span> infoContractor <span class="hljs-keyword">in</span> detailTags:
<span class="hljs-keyword">if</span> infoContractor.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonAggregateComponents-2}Party"</span>:
<span class="hljs-keyword">for</span> contractorDetails <span class="hljs-keyword">in</span> infoContractor:
<span class="hljs-keyword">if</span> contractorDetails.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonAggregateComponents-2}PartyName"</span> :
<span class="hljs-keyword">for</span> name <span class="hljs-keyword">in</span> contractorDetails:
licitacion[<span class="hljs-string">"contratante"</span>] = name.text
<span class="hljs-keyword">elif</span> contractorDetails.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonBasicComponents-2}WebsiteURI"</span>:
licitacion[<span class="hljs-string">"urlcontratante"</span>] = contractorDetails.text
<span class="hljs-keyword">elif</span> detailTags.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice-place-ext:schema:xsd:CommonAggregateComponents-2}ContractFolderStatusCode"</span>:
licitacion[<span class="hljs-string">"estado"</span>] = detailTags.text
<span class="hljs-keyword">elif</span> detailTags.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonAggregateComponents-2}ProcurementProject"</span>:
<span class="hljs-keyword">for</span> infoProcurement <span class="hljs-keyword">in</span> detailTags:
<span class="hljs-keyword">if</span> infoProcurement.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonAggregateComponents-2}BudgetAmount"</span>:
<span class="hljs-keyword">for</span> detailBudget <span class="hljs-keyword">in</span> infoProcurement:
<span class="hljs-keyword">if</span> detailBudget.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonBasicComponents-2}EstimatedOverallContractAmount"</span>:
licitacion[<span class="hljs-string">"valorestimado"</span>] = detailBudget.text
<span class="hljs-keyword">elif</span> detailBudget.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonBasicComponents-2}TotalAmount"</span>:
licitacion[<span class="hljs-string">"importetotal"</span>] = detailBudget.text
<span class="hljs-keyword">elif</span> detailBudget.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonBasicComponents-2}TaxExclusiveAmount"</span>:
licitacion[<span class="hljs-string">"importetotalsinimpuestos"</span>] = detailBudget.text
<span class="hljs-keyword">elif</span> infoProcurement.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonAggregateComponents-2}RequiredCommodityClassification"</span>:
<span class="hljs-keyword">for</span> detailClassification <span class="hljs-keyword">in</span> infoProcurement:
<span class="hljs-keyword">if</span> detailClassification.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonBasicComponents-2}ItemClassificationCode"</span>:
licitacion[<span class="hljs-string">"clasificacion"</span>] = detailClassification.text
<span class="hljs-keyword">elif</span> infoProcurement.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonAggregateComponents-2}RealizedLocation"</span>:
<span class="hljs-keyword">for</span> detailLocalization <span class="hljs-keyword">in</span> infoProcurement:
<span class="hljs-keyword">if</span> detailLocalization.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonBasicComponents-2}CountrySubentity"</span>:
licitacion[<span class="hljs-string">"localizacion"</span>] = detailLocalization.text
<span class="hljs-keyword">elif</span> detailTags.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonAggregateComponents-2}TenderResult"</span>:
<span class="hljs-keyword">for</span> infoResult <span class="hljs-keyword">in</span> detailTags:
<span class="hljs-keyword">if</span> infoResult.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonBasicComponents-2}AwardDate"</span>:
licitacion[<span class="hljs-string">"fechaadjudicacion"</span>] = infoResult.text
<span class="hljs-keyword">elif</span> infoResult.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonAggregateComponents-2}WinningParty"</span>:
<span class="hljs-keyword">for</span> detailWinner <span class="hljs-keyword">in</span> infoResult:
<span class="hljs-keyword">if</span> detailWinner.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonAggregateComponents-2}PartyName"</span>:
<span class="hljs-keyword">for</span> detailName <span class="hljs-keyword">in</span> detailWinner:
<span class="hljs-keyword">if</span> detailName.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonBasicComponents-2}Name"</span>:
licitacion[<span class="hljs-string">"ganador"</span>] = detailName.text
<span class="hljs-keyword">elif</span> infoResult.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonAggregateComponents-2}AwardedTenderedProject"</span>:
<span class="hljs-keyword">for</span> detailTender <span class="hljs-keyword">in</span> infoResult:
<span class="hljs-keyword">if</span> detailTender.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonAggregateComponents-2}LegalMonetaryTotal"</span>:
<span class="hljs-keyword">for</span> detailWinnerAmount <span class="hljs-keyword">in</span> detailTender:
<span class="hljs-keyword">if</span> detailWinnerAmount.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonBasicComponents-2}TaxExclusiveAmount"</span>:
licitacion[<span class="hljs-string">"importeganadorsinimpuestos"</span>] = detailWinnerAmount.text
<span class="hljs-keyword">elif</span> detailWinnerAmount.tag == <span class="hljs-string">"{urn:dgpe:names:draft:codice:schema:xsd:CommonBasicComponents-2}PayableAmount"</span>:
licitacion[<span class="hljs-string">"importeganador"</span>] = detailWinnerAmount.text
iris.cls(<span class="hljs-string">"Ens.Util.Log"</span>).LogInfo(<span class="hljs-string">"Inquisidor.BP.XMLToLicitacion"</span>, <span class="hljs-string">"VectorizePatient"</span>, <span class="hljs-string">"Terminado mapeo "</span>+licitacion[<span class="hljs-string">"titulo"</span>])
<span class="hljs-keyword">if</span> licitacion.get(<span class="hljs-string">"importeganador"</span>) <span class="hljs-keyword">is</span> <span class="hljs-keyword">not</span> <span class="hljs-keyword">None</span> <span class="hljs-keyword">and</span> licitacion.get(<span class="hljs-string">"importeganador"</span>) <span class="hljs-keyword">is</span> <span class="hljs-keyword">not</span> <span class="hljs-string">""</span>:
iris.cls(<span class="hljs-string">"Ens.Util.Log"</span>).LogInfo(<span class="hljs-string">"Inquisidor.BP.XMLToLicitacion"</span>, <span class="hljs-string">"VectorizePatient"</span>, <span class="hljs-string">"Lanzando insert "</span>+licitacion[<span class="hljs-string">"titulo"</span>])
stmt = iris.sql.prepare(<span class="hljs-string">"INSERT INTO INQUISIDOR_Object.Licitacion (Titulo, Resumen, IdLicitacion, URL, Contratante, URLContratante, Estado, ValorEstimado, ImporteTotal, ImporteTotalSinImpuestos, Clasificacion, Localizacion, FechaAdjudicacion, Ganador, ImporteGanadorSinImpuestos, ImporteGanador) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,TO_DATE(?,'YYYY-MM-DD'),?,?,?)"</span>)
<span class="hljs-keyword">try</span>:
rs = stmt.execute(licitacion[<span class="hljs-string">"titulo"</span>], licitacion[<span class="hljs-string">"resumen"</span>], licitacion[<span class="hljs-string">"idlicitacion"</span>], licitacion[<span class="hljs-string">"url"</span>], licitacion[<span class="hljs-string">"contratante"</span>], licitacion[<span class="hljs-string">"urlcontratante"</span>], licitacion[<span class="hljs-string">"estado"</span>], licitacion[<span class="hljs-string">"valorestimado"</span>], licitacion[<span class="hljs-string">"importetotal"</span>], licitacion[<span class="hljs-string">"importetotalsinimpuestos"</span>], licitacion[<span class="hljs-string">"clasificacion"</span>], licitacion[<span class="hljs-string">"localizacion"</span>], licitacion[<span class="hljs-string">"fechaadjudicacion"</span>], licitacion[<span class="hljs-string">"ganador"</span>], licitacion[<span class="hljs-string">"importeganadorsinimpuestos"</span>], licitacion[<span class="hljs-string">"importeganador"</span>])
<span class="hljs-keyword">except</span> Exception <span class="hljs-keyword">as</span> err:
iris.cls(<span class="hljs-string">"Ens.Util.Log"</span>).LogInfo(<span class="hljs-string">"Inquisidor.BP.XMLToLicitacion"</span>, <span class="hljs-string">"VectorizePatient"</span>, repr(err))
<span class="hljs-keyword">return</span> <span class="hljs-string">"Success"</span>
<span class="hljs-keyword">except</span> Exception <span class="hljs-keyword">as</span> err:
iris.cls(<span class="hljs-string">"Ens.Util.Log"</span>).LogInfo(<span class="hljs-string">"Inquisidor.BP.XMLToLicitacion"</span>, <span class="hljs-string">"VectorizePatient"</span>, repr(err))
<span class="hljs-keyword">return</span> <span class="hljs-string">"Error"</span>
}
Une fois le mappage terminé, nous procédons à un simple insert avec l'enregistrement.
Pour le mappage en utilisant ObjectScript, j'ai utilisé la fonctionnalité %XML.TextReader , voyons la méthode:
Method OnRequest(pRequest As Ens.StreamContainer, Output pResponse As Ens.Response) As%Status
{
set filename = pRequest.OriginalFilename
set status=##class(%XML.TextReader).ParseFile(filename,.textreader)
//check statusif$$$ISERR(status) {do$System.Status.DisplayError(status) quit}
set tStatement = ##class(%SQL.Statement).%New()
//iterate through document, node by nodewhile textreader.Read()
{
if ((textreader.NodeType = "element") && (textreader.Depth = 2) && (textreader.Path = "/feed/entry")) {
if ($DATA(licitacion))
{
if (licitacion.ImporteGanador '= ""){
//set sc = licitacion.%Save()set myquery = "INSERT INTO INQUISIDOR_Object.LicitacionOS (Titulo, Resumen, IdLicitacion, URL, Contratante, URLContratante, Estado, ValorEstimado, ImporteTotal, ImporteTotalSinImpuestos, Clasificacion, Localizacion, FechaAdjudicacion, Ganador, ImporteGanadorSinImpuestos, ImporteGanador) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"set qStatus = tStatement.%Prepare(myquery)
if qStatus '= 1 {
write"%Prepare failed:"do$System.Status.DisplayError(qStatus)
quit
}
set rset = tStatement.%Execute(licitacion.Titulo, licitacion.Resumen, licitacion.IdLicitacion, licitacion.URL, licitacion.Contratante, licitacion.URLContratante, licitacion.Estado, licitacion.ValorEstimado, licitacion.ImporteTotal, licitacion.ImporteTotalSinImpuestos, licitacion.Clasificacion, licitacion.Localizacion, licitacion.FechaAdjudicacion, licitacion.Ganador, licitacion.ImporteGanadorSinImpuestos, licitacion.ImporteGanador)
}
}
set licitacion = ##class(Inquisidor.Object.LicitacionOS).%New()
}
if (textreader.Path = "/feed/entry/title"){
if (textreader.Value '= ""){
set licitacion.Titulo = textreader.Value
}
}
if (textreader.Path = "/feed/entry/summary"){
if (textreader.Value '= ""){
set licitacion.Resumen = textreader.Value
}
}
if (textreader.Path = "/feed/entry/id"){
if (textreader.Value '= ""){
set licitacion.IdLicitacion = textreader.Value
}
}
if (textreader.Path = "/feed/entry/link"){
if (textreader.MoveToAttributeName("href")) {
set licitacion.URL = textreader.Value
}
}
if (textreader.Path = "/feed/entry/cac-place-ext:ContractFolderStatus/cbc-place-ext:ContractFolderStatusCode"){
if (textreader.Value '= ""){
set licitacion.Estado = textreader.Value
}
}
if (textreader.Path = "/feed/entry/cac-place-ext:ContractFolderStatus/cac-place-ext:LocatedContractingParty/cac:Party/cac:PartyName"){
if (textreader.Value '= ""){
set licitacion.Contratante = textreader.Value
}
}
if (textreader.Path = "/feed/entry/cac-place-ext:ContractFolderStatus/cac-place-ext:LocatedContractingParty/cac:Party/cbc:WebsiteURI"){
if (textreader.Value '= ""){
set licitacion.URLContratante = textreader.Value
}
}
if (textreader.Path = "/feed/entry/cac-place-ext:ContractFolderStatus/cac:ProcurementProject/cac:BudgetAmount/cbc:EstimatedOverallContractAmount"){
if (textreader.Value '= ""){
set licitacion.ValorEstimado = textreader.Value
}
}
if (textreader.Path = "/feed/entry/cac-place-ext:ContractFolderStatus/cac:ProcurementProject/cac:BudgetAmount/cbc:TotalAmount"){
if (textreader.Value '= ""){
set licitacion.ImporteTotal = textreader.Value
}
}
if (textreader.Path = "/feed/entry/cac-place-ext:ContractFolderStatus/cac:ProcurementProject/cac:BudgetAmount/cbc:TaxExclusiveAmount"){
if (textreader.Value '= ""){
set licitacion.ImporteTotalSinImpuestos = textreader.Value
}
}
if (textreader.Path = "/feed/entry/cac-place-ext:ContractFolderStatus/cac:ProcurementProject/cac:RequiredCommodityClassification/cbc:ItemClassificationCode"){
if (textreader.Value '= ""){
set licitacion.Clasificacion = textreader.Value
}
}
if (textreader.Path = "/feed/entry/cac-place-ext:ContractFolderStatus/cac:ProcurementProject/cac:RealizedLocation/cbc:CountrySubentity"){
if (textreader.Value '= ""){
set licitacion.Localizacion = textreader.Value
}
}
if (textreader.Path = "/feed/entry/cac-place-ext:ContractFolderStatus/cac:TenderResult/cbc:AwardDate"){
if (textreader.Value '= ""){
set licitacion.FechaAdjudicacion = $System.SQL.Functions.TODATE(textreader.Value,"YYYY-MM-DD")
}
}
if (textreader.Path = "/feed/entry/cac-place-ext:ContractFolderStatus/cac:TenderResult/cac:WinningParty/cac:PartyName/cbc:Name"){
if (textreader.Value '= ""){
set licitacion.Ganador = textreader.Value
}
}
if (textreader.Path = "/feed/entry/cac-place-ext:ContractFolderStatus/cac:TenderResult/cac:AwardedTenderedProject/cac:LegalMonetaryTotal/cbc:TaxExclusiveAmount"){
if (textreader.Value '= ""){
set licitacion.ImporteGanadorSinImpuestos = textreader.Value
}
}
if (textreader.Path = "/feed/entry/cac-place-ext:ContractFolderStatus/cac:TenderResult/cac:AwardedTenderedProject/cac:LegalMonetaryTotal/cbc:PayableAmount"){
if (textreader.Value '= ""){
set licitacion.ImporteGanador = textreader.Value
}
}
}
// set resultEmbeddings = ..GenerateEmbeddings()Quit$$$OK
}Les deux codes n'enregistreront dans la base de données que les concours qui ont déjà été résolus (pour lesquels le montant total gagnant a été communiqué).
Avec nos méthodes mises en œuvre dans les processus métier correspondants, il ne nous reste plus qu'à configurer la production pour notre test, ce qui nous permettra d'alimenter les deux méthodes. Il suffit d'ajouter deux services métier qui se limiteront à capturer les fichiers avec les informations XML et à les transmettre aux processus métier.
Pour éviter toute interférence lors de la capture et de la transmission des informations aux processus métier, nous allons créer deux services métier. La production se présentera comme suit:
.png)
Pour le test, nous allons introduire les concours publics du mois de février, soit un total de 91 fichiers avec 1,30 Go de données. Voyons comment se comportent les deux codes.
À vos marques...
Prêts...
C'est parti!
Commençons par le temps nécessaire au code ObjectScript pour mapper les 91 fichiers:
.png)
Le premier fichier a été démarré à 21:11:15, voyons quand le dernier fichier a été mappé:
.png)
Si nous regardons les détails du dernier message, nous pouvons voir la date finale du traitement:
.png)
L'heure finale est 21:17:43, ce qui donne un temps de traitement de 6 minutes et 28 secondes.
Répétez la même opération avec le processus qui utilise Python:
.png)
Début à 21:11:15 comme dans le cas précédent, voyons quand l'opération s'est terminée:
.png)
Voyons le message en détail pour connaître la fin exacte:
.png)
L'heure finale était 21:12:03, ce qui nous amène à un total de 48 secondes.
Eh bien, le gagnant est connu ! Dans ce round, Embedded Python a battu ObjectScript, du moins en ce qui concerne l'analyse XML. Si vous avez des suggestions ou des améliorations à apporter au code des deux méthodes, je vous encourage à les mettre dans les commentaires et je répéterai les tests pour vérifier les améliorations possibles.
Ce que nous pouvons dire, c'est qu'en ce qui concerne la supériorité évidente de la performance d'ObjectScript par rapport à Python... le mythe est brisé!
Une API REST (Representational State Transfer) est une interface qui permet de faire communiquer différentes applications entre elles via le protocole HTTP, en utilisant des opérations standard telles que GET, POST, PUT, et DELETE. Les API REST sont largement utilisées dans le développement de logiciels pour exposer des services accessibles par d'autres applications, permettant ainsi l'intégration entre différents systèmes.
Cependant, pour garantir que les APIs soient faciles à comprendre et à utiliser, une bonne documentation est essentielle. C'est là qu'OpenAPI entre en jeu.
OpenAPI est une norme de description pour les APIs RESTful. Elle permet de définir de manière structurée les fonctionnalités d'une API, en spécifiant les extrémités disponibles, les types de données acceptés et renvoyés, les paramètres requis et les réponses attendues. Toutes ces informations sont rassemblées dans un fichier de spécification (généralement avec une extension .yaml ou .json), qui peut être interprété par des outils automatisés pour générer du code, de la documentation, etc.
La spécification OpenAPI Specification est conçue pour être lisible par les machines et les humains, permettant la description, la production, la consommation et la visualisation de services web RESTful de manière standardisée. Par conséquent, un document OpenAPI représente une description formelle de l'API, utile à la fois pour les développeurs qui ont besoin de l'utiliser et pour les outils qui peuvent l'exploiter pour automatiser divers processus.
L'adoption d'OpenAPI pour documenter une API offre plusieurs avantages, notamment:
Il existe deux approches principales pour générer un fichier de spécification OpenAPI:
Il existe deux façons de générer automatiquement le fichier de spécification OpenAPI dans InterSystems IRIS.
GetWebRESTApplicationUne approche consiste à utiliser la fonction GetWebRESTApplication fournie par la classe %REST.API.
Un exemple pratique d'utilisation consiste à ajouter la fonction suivante dans la classe de répartition:
ClassMethod GenerateOpenAPI() As%Status
{
// Le nom de l'application RESTSet webApplication = "MyAPP"// Remplacez par le nom de votre application web// Récupérez la documentation OpenAPI 2.0Set sc = ##class(%REST.API).GetWebRESTApplication("", webApplication, .swagger)
<span class="hljs-keyword">If</span> <span class="hljs-built_in">$$$ISERR</span>(sc) {
<span class="hljs-keyword">Quit</span> sc <span class="hljs-comment">// Si une erreur s'est produite, quittez la méthode</span>
}
<span class="hljs-comment">// Renvoyez la documentation au format JSON</span>
<span class="hljs-keyword">Set</span> <span class="hljs-built_in">%response.ContentType</span> = <span class="hljs-string">"application/json"</span>
<span class="hljs-keyword">Do</span> <span class="hljs-keyword">##class</span>(OMRREST.impl).<span class="hljs-built_in">%WriteResponse</span>(swagger.<span class="hljs-built_in">%ToJSON</span>())
<span class="hljs-keyword">Quit</span> <span class="hljs-built_in">$$$OK</span>
}
Ajoutez en outre le chemin d'accès suivant à l'UrlMap:
<Route Url="/openapi" Method="GET" Call="GenerateOpenAPI"/>
À ce stade, vous aurez tout ce qu'il vous faut pour générer le fichier de spécification à partir de votre classe d'envoi. Pour consulter la documentation, connectez-vous à l'URL indiquée (où MyWebapp est le nom de votre application web, tel que défini dans le portail de gestion):
<host>:<port>/MyWebapp/openapiLe JSON ainsi généré représente la spécification OpenAPI de votre API. Après avoir exploré la deuxième méthode, nous verrons comment la visualiser et la tester dans Swagger.
Une autre façon de générer le fichier de spécification OpenAPI consiste à utiliser l' API de gestion InterSystems IRIS.
Pour appeler ce service, vous pouvez utiliser des outils tels que Postman, un outil de développement qui vous permet de tester, documenter et automatiser les API.
Postman fournit une interface simple et intuitive pour l'envoi de requêtes HTTP (GET, POST, PUT, DELETE, etc.), la visualisation des réponses, la gestion de l'authentification et la création de tests automatisés.
Pour formuler la requête à l'aide de Postman, procédez comme suit:
New et créez une requête HTTP. .png)
<baseURL> de votre instance:
https://<baseURL>/api/mgmnt/v1/namespace/myappIci,
namespace est le nom de l'espace de noms où vous avez créé d le service REST, et myapp et le nom de votre application..png)
Une fois le JSON généré, il peut être visualisé et testé à l'aide d'outils tels que Swagger Editor.
{
"info":{
"title":"",
"description":"",
"version":"",
"x-ISC_Namespace":"MyNamespace"
},
"basePath":"/MyWebapp",
"paths":{
"/loginForm":{
"post":{
"parameters":[
{
"name":"payloadBody",
"in":"body",
"description":"Request body contents",
"required":false,
"schema":{
"type":"string"
}
}
],
"operationId":"loginForm",
"x-ISC_ServiceMethod":"loginForm",
"responses":{
"default":{
"description":"(Unexpected Error)"
},
"200":{
"description":"(Expected Result)"
}
}
}
},
"/refresh":{
"post":{
"parameters":[
{
"name":"payloadBody",
"in":"body",
"description":"Request body contents",
"required":false,
"schema":{
"type":"string"
}
}
],
"operationId":"refresh",
"x-ISC_ServiceMethod":"refresh",
"responses":{
"default":{
"description":"(Unexpected Error)"
},
"200":{
"description":"(Expected Result)"
}
}
}
},
"/logout":{
"post":{
"parameters":[
{
"name":"payloadBody",
"in":"body",
"description":"Request body contents",
"required":false,
"schema":{
"type":"string"
}
}
],
"operationId":"logout",
"x-ISC_ServiceMethod":"logout",
"responses":{
"default":{
"description":"(Unexpected Error)"
},
"200":{
"description":"(Expected Result)"
}
}
}
},
"/openapi":{
"get":{
"operationId":"GenerateOpenAPI",
"x-ISC_ServiceMethod":"GenerateOpenAPI",
"responses":{
"default":{
"description":"(Unexpected Error)"
},
"200":{
"description":"(Expected Result)"
}
}
}
}
},
"swagger":"2.0"
}.png)
.png)
L'approche manuelle pour générer un document OpenAPI consiste à écrire manuellement le fichier de spécification au format YAML ou JSON. Cette approche est particulièrement utile lorsque vous souhaitez contrôler entièrement la conception de l'API avant sa mise en œuvre, ou lorsque vous documentez une API déjà existante sans recourir à des outils automatisés.
Pour rédiger le fichier de spécification OpenAPI, vous pouvez vous référer à , la documentation officielle de la version 2.0 de la spécification OpenAPI, où vous trouverez des renseignements sur les champs obligatoires et sur la manière de décrire les points de terminaison, les paramètres, les réponses, etc. Ce guide détaillé vous aidera à comprendre comment structurer correctement le fichier YAML ou JSON afin de respecter les normes OpenAPI.
Un bon exemple d'utilisation de cette approche est la création d'un service REST à l'aide des méthodes décrites dans la documentation officielle d'InterSystems IRIS.
Vous trouverez une introduction au développement et à la configuration d'une application REST dans IRIS sur cette page de la documentation, qui décrit étape par étape les méthodes nécessaires pour exposer une application RESTful avec IRIS.
Je me suis lancé un défi : trouver un moyen de faire en sorte qu'une variable se surveille elle-même pour une certaine valeur et fasse quelque chose lorsqu'elle atteint cette valeur sans avoir à la vérifier à chaque fois que quelque chose la touche. En gros, un moyen de dire "à un moment donné pendant l'exécution de ce code, si x = 0 (ou quelle que soit la condition) faire ceci". La classe avec laquelle j'ai fini par surveiller un %Status :
Tout d'abord, permettez-moi de souhaiter une bonne année à la Communauté des Développeurs ! Nous espérons vous apporter beaucoup de bonnes choses cette année, et aujourd'hui, j'aimerais vous présenter la dernière version de l'extension Intersystems Language Server pour VS Code. La plupart des améliorations de Language Server sont expérimentées via l'interface utilisateur de l'extension ObjectScript, vous n'êtes donc peut-être pas au courant des nombreuses améliorations dans des domaines tels qu'Intellisense et les survols qui ont été publiées tout au long de l'année 2024. Veuillez lire
InterSystems a corrigé un défaut qui provoque l'introduction d'enregistrements de base de données et de journaux non valides lors de l'utilisation d'une syntaxe $LIST spécifique. La probabilité de rencontrer ce défaut est très faible, mais les impacts opérationnels peuvent être importants.
Produits concernés