Embedded Python dans InterSystems IRIS - 2
Dans l'article précédent. Pratiques des membres de la classe et leur exécution au sein de Embedded Python. WNous allons maintenant aborder le processus de changement d'espace de noms, d'accès aux variables globales, de traversée et d'exécution de routine au sein de Embedded Python.
Avant de passer aux autres fonctions, examinons brièvement la fonction execute du paquet iris. Cette fonction est particulièrement utile pour l'exécution de fonctions ObjectScript arbitraires et l'invocation de classes.
>>> b
'aaaa'
>>> b = iris.execute('return $Extract("123456",2,5)')
>>> b
'2345'
>>> b = iris.execute('return $Length(123456)')
>>> iris.execute('write ##Class(%SYSTEM.SYS).NameSpace()')
LEARNING>>>
>>> b = iris.execute('return ##Class(%SYSTEM.SYS).NameSpace()')
>>> b
'LEARNING'
Commençons!
4. Changement d'espace de noms
Il est souvent nécessaire de changer d'espace de noms en cours d'exécution. Toutefois, contrairement à IRIS, il n'est pas possible de changer directement d'espace de noms dans Embedded Python. Il est donc essentiel d'utiliser les définitions de classes existantes ou de créer une méthode wrapper pour faciliter le changement d'espace de noms.
ClassMethod SwitchNM() [ Language = python ]
{
import iris
print(iris.cls('%SYSTEM.SYS').NameSpace())
print(iris.system.Process.SetNamespace("USER"))
try:
iris.cls('User.EmbeddedPython').pyGetTemplateString()
except RuntimeError as e:
print("Wrong NameSpace",e)
}
5. Globale
Pour utiliser les capacités d'une globale pour les données de la traversée ou pour l'extraction directe d'informations à partir de systèmes globaux existants, plutôt que par le biais de SQL ou d'objets dans Embedded Python, on peut y accéder directement en employant la fonction gref du paquetage iris. Pour définir ou obtenir des valeurs globales, la fonction gref peut être utilisée pour établir une référence à la variable globale et assigner directement des valeurs dans Python.
| Objet de référence global d'InterSystems IRIS.
| UUtilisez la méthode iris.gref() pour obtenir une référence à une globale
|
| Les méthodes sont définies ci-dessous:
|
| __delitem__(self, key, /)
| Suppression de self[key].
|
| __getitem__(self, key, /)
| Renvoie de self[key].
|
| __len__(self, /)
| Renvoie de len(self).
|
| __repr__(self, /)
| Renvoie de repr(self).
|
| __setitem__(self, key, value, /)
| Mise à la valeur de self[key].
|
| __str__(self, /)
| Renvoie de str(self).
|
| data(self, key)
| Étant donné les clés d'une globale sous forme de liste, renvoie son état.
| Exemple : x = g.data([i,j]) attribue à x les valeurs 0,1,10,11 0-si indéfini, 1-défini, 10-indéfini mais a des descendants, 11-a une valeur et des descendants
|
| get(self, key)
| Étant donné les clés d'un global sous forme de liste, renvoie la valeur stockée à ce nœud de globales.
| Exemple : x = g.get([i,j]) attribue à x la valeur stockée à la clé i,j de globale g.
|
| getAsBytes(self, key)
| Étant donné les clés d'une globale sous forme de liste, renvoie une chaîne de caractères stockée à ce nœud de la globale, sous forme d'octets.
| Exemple : x = g.getAsBytes([i,j]) attribue à x la valeur stockée à la clé i,j de la globale g, sous forme d'octets.
|
| keys(self, key)
| Traverse une globale à partir de la clé spécifiée, en retournant chaque clé dans la globale.
| Exemple : for key in g.keys([i, j]) traverse g à partir de la clé i,j, en retournant chaque clé à son tour. Deuxième argument facultatif 1 ou -1, si -1 inverse l'ordre retourné
|
| kill(self, key)
| Étant donné les clés d'une globale sous forme de liste, supprime ce nœud de la globale et sa sous-arborescence.
| Exemple : g.kill([i,j]) supprime le nœud stocké à la clé i,j de la globale g et tous ses descendants.
|
| order(self, key)
| Étant donné les clés d'une globale sous forme de liste, renvoie la clé suivante de la globale, second argument facultatif 1 ou -1, si -1 renvoie la clé précédente.
| Exemple : j = g.order([i,j]) attribue à j la clé de deuxième niveau suivante de la globale g.
|
| orderiter(self, key)
| Traverse une globale à partir de la clé spécifiée, en renvoyant la clé et la valeur suivantes sous la forme d'un tuple.
| Exemple : pour (clé, valeur) dans g.orderiter([i,j]) traverse g à partir de la clé i,j, en renvoyant la clé et la valeur suivantes. Deuxième argument facultatif : 1 ou -1, si -1, l'ordre retourné est inversé.
|
| query(self, key)
| Traverse une globale à partir de la clé spécifiée, en renvoyant chaque clé et chaque valeur sous la forme d'un tuple.
| Exemple : pour (clé, valeur) dans g.query([i,j]) traverse g à partir de la clé i,j, en renvoyant chaque clé et chaque valeur à tour de rôle. Deuxième argument facultatif : 1 ou -1, si -1, l'ordre retourné est inversé.
|
| set(self, key, value)
| Étant donné les clés d'une globale sous forme de liste, définit la valeur stockée à cette clé de la globale.
| Exemple : g.set([i,j], 10) fixe la valeur du nœud à la clé i,j de la globale g à 10
|
| ----------------------------------------------------------------------
| Les méthodes statiques sont définies ci-dessous:
|
| __new__(*args, **kwargs) from builtins.type
| Création et retour d'un nouvel objet. Consultez help(type) pour obtenir une signature précise.
5.1 Définition des valeurs globales
ClassMethod SetGlobal() [ Language = python ]
{
import iris
#création d'une référence globale
g = iris.gref('^mygbl')
g[1],g[2]='Mon','Tue'
g["95752455",1]=iris.execute('return $LFS("Ashok,55720,9639639639,test@gmail.com",",")')
g["85752400",1]=iris.execute('return $LB("Test","9517539635","t@gmail.com")')
g["test","c1"]=iris.execute('return ##Class(MyLearn.EmbeddedPython).executeAndGetResult()') # method wil return some listbuild values# déclaration de valeurs à l'aide de la fonction set
g.set([3],'Wed')
g.set([3,1,1],'Test multilevel')
}
5.2 Obtention des valeurs globales
Récupérez les valeurs globales à partir de python directement en utilisant la méthode subscripts ou get.
ClassMethod GetGlobal() [ Language = python ]
{
import iris
#obtient une référence globale
g = iris.gref('^mybgl')
# obtention de valeurs
print(g[3,1,1])
print(g.get([2,1]))
print(g["95752455",1])
}
5.3 Traversée
order - Traverser la globale est essentiel pour collecter plusieurs niveaux de données de la globale. Cette commande en Embedded Python order fonctionne de manière similaire à la commande $Order en utilisant la fonction order du fichier iris.gref. Au départ, il est nécessaire d'établir une référence à l'entité globale qui doit être traversée.
Traversée à un seul niveau d'indice
ClassMethod DollarOrder() [ Language = python ]
{
import iris
g = iris.gref('^MyLearn.EmbeddedPythonD') # I use my persistent class global
key = ''
while True:
key = g.order([key])
if key == None:
breakprint(f'{key} {g.get([key])}')
}Traversée à plusieurs niveaux d'indices
^mygbl(1)="Mon"
^mygbl(2)="Tue"
^mygbl(3)="Wed"
^mygbl(3,1,1)="Test multilevel"
^mygbl(85752400,1)=$lb("Test","9517539635","t@gmail.com")
^mygbl(95752455,1)=$lb("Ashok","55720","9639639639","test@gmail.com")
^mygbl("test","c1")=$lb("Test","8527538521","pylearn@gmail.com")
ClassMethod DollarOrderMultiLevel() [ Language = python ]
{
import iris
g = iris.gref('^mygbl')
key1= ''whileTrue:
key1 = g.order([key1])
if key1== None:
break
key2 = ''whileTrue:
key2 = g.order([key1,key2])
if key2 == None:
break
value = g.get([key1,key2])
print(key1,key2,value)
}
query - La fonction de requête à partir de iris.gref est similaire à $query. Cette fonction is rassemble toutes les valeurs globales en tuples. Le résultat du tuple contient les identifiants dans la liste et les valeurs sont le tuple suivant. Vous pouvez consulter l'exemple de tuple ci-dessous
zw ^mybgl
^mybgl(1)="Mon"
^mybgl(2)="Tue"
^mybgl(3)="Wed"
^mybgl(3,1,1)="Test multilevel"
^mybgl(95752455,1)=$lb("Ashok","55720","9639639639","test@gmail.com")
Python tuple : ( [ids], data)
(['1'], 'Mon')
(['2'], 'Tue')
(['3'], 'Wed')
(['3', '1', '1'], 'Test multilevel')
(['95752455', '1'], '\x07\x01Ashok\x07\x0155720\x0c\x019639639639\x10\x01test@gmail.com')
ClassMethod DollarQuery() [ Language = python ]
{
import iris
g = iris.gref('^mygbl')
key = g.query()#cela renverra des tuples de tous les indicesfor x in key:
print(x) # résultat (['3', '1', '1'], 'Test multilevel')
}data - la fonction data Vérifie si l'indice donné existe dans le global et renvoie les valeurs $data en utilisant la fonction de données
ClassMethod DollarData() [ Language = python ]
{
import iris
g = iris.gref('^mygbl')
key1= ''
print(g.data([1]))
}
6. Routines
En outre, il est essentiel d'implémenter les membres de la classe. Nous devons exécuter les routines dans le cadre de la mise en œuvre pour les systèmes de base de code hérités et d'autres situations connexes. Par conséquent, il existe une fonction spécifique dans le paquet de la bibliothèque iris qui permet l'invocation de routines à partir de Embedded Python grâce à l'utilisation de la fonction routine.
w 123
q
ir1
w "running ir1"
q
add(p1,p2) public{
return p1+p2
}
sub(p1,p2)
s c= p1-p2
ClassMethod RunRoutines() [ Language = python ]
{
import iris
iris.routine('^myirispython')
iris.routine('add^myirispython',1,2) # same aswrite$$add^myirispython(1,2)
}
En outre, vous pouvez également exécuter la routine à l'aide de la fonction d'exécution. iris.execute('do ^myirispython')
>>> iris.routine('^myirispythonT')
Traceback (dernier appel récent):
File "<input>", line 1, in <module>
RuntimeError: Routine introuvable
Les autres sujets seront abordés dans le prochain article.