No artigo anterior. Práticas de membros de classe e sua execução dentro do Python embutido. Agora voltaremos nossa atenção para o processo de alternância de espaços de nomes, acesso a variáveis globais, travessia e execução de rotinas dentro do Python embutido.
Antes de prosseguir para as outras funções. vamos revisar brevemente a função execute
dentro do pacote iris. Esta função é excepcionalmente benéfica para executar funções ObjectScript arbitrárias e invocação de classe.
>>> b = iris.execute('return $Piece("test^aaaa","^",2)')
>>> 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'
Vamos começar!
4. Mudar Namespaces
A troca de espaços de nomes durante a execução é frequentemente necessária. No entanto, diferentemente do IRIS, a troca direta de espaços de nomes dentro do Python embutido não é viável. Portanto, é essencial utilizar definições de classe existentes ou criar um método wrapper para facilitar a troca de namespaces.
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. Global
Para utilizar as capacidades de global para travessia de dados ou para recuperar informações de sistemas globais legados diretamente, em vez de usar SQL ou objetos dentro do Python embutido, é possível acessá-lo diretamente empregando a função gref do pacote iris. Para definir ou obter valores globais, a função gref pode ser utilizada para estabelecer uma referência à variável global e atribuir valores diretamente dentro do Python.
class gref(builtins.object)
| Objeto de referência de global do InterSystems IRIS.
| Use o método iris.gref() para obter referência a uma global
|
| Métodos definidos aqui:
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __getitem__(self, key, /)
| Return self[key].
|
| __len__(self, /)
| Return len(self).
|
| __repr__(self, /)
| Return repr(self).
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __str__(self, /)
| Return str(self).
|
| data(self, key)
| Dadas as chaves de uma global como uma lista, retorna o estado dela.
| Exemplo: x = g.data([i,j]) define x para 0,1,10,11 0-se não definido, 1-definido, 10-indefinido, mas tem descentendes, 11-tem valor e descendentes
|
| get(self, key)
| Dadas as chaves de uma global como uma lista, retorna o valor guardado no nó da global
| Exemplo: x = g.get([i,j]) define x no valor guardado na chave i,j da global g
|
| getAsBytes(self, key)
| Dadas as chaves da global como uma lista, retorna uma string guardada no nó daquela global, como bytes
| Exemplo: x = g.getAsBytes([i,j]) define x ao valor guardado na chave i,j, da global g, como bytes
|
| keys(self, key)
| Faz a travessia de uma global iniciando na chave especificada, retornando cada chave na global.
| Exemplo: para cada chave em g.keys([i, j]) atravessa g da chave i,j, retornando cada chave em cada vez. Opcional segundo argumento 1 ou -1, se -1 faz a travessia na ordem reversa.
|
| kill(self, key)
| Dadas as chaves de uma global como uma lista, mata aquele nó da glboal e sua subárvore
| Exemplo: g.kill([i,j]) mata o nó guardado na chave i,j da global g e qualquer descendente.
|
| order(self, key)
| Dadas as chaves de uma global como uma lista, retorna a próxima chave da global, segundo argumento opcional 1 ou -1, se -1 retorna a chave anterior.
| Exemplo: j = g.order([i,j]) define j para a próxima chave de segundo nível da global g
|
| orderiter(self, key)
| Atravessa uma global iniciando na chave especificada, retornando a próxima chave e valor como uma tupla.
| Exemplo: para cada (key, value) em g.orderiter([i,j]) atravessa g da chave i,j, retornando a próxima chave e valor. Segundo argumento opcional 1 ou -1, se -1 faz a ordem reversa.
|
| query(self, key)
| Atravessa uma global iniciando na chave especificada, retornando cada chave e valor como uma tupla.
| Exemplo: para cada (key, value) em g.query([i,j]) atravessa g da chave i,j, retornando cada chave e valor em troca. Segundo argumento opcional 1 ou -1, se -1 reverte a ordem retornada.
|
| set(self, key, value)
| Dadas as chaves de uma global como uma lista, define o valor guardado na chave da global.
| Exemplo: g.set([i,j], 10) define o valor do nó na chave i,j da global g para 10
|
| ----------------------------------------------------------------------
| Métodos estáticos definidos aqui:
|
| __new__(*args, **kwargs) from builtins.type
| Cria e retorna um novo objeto. Veja help(type) para assinatura correta.
5.1 Definir valores de global
ClassMethod SetGlobal() [ Language = python ]
{
import iris
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()')
g.set([3],'Wed')
g.set([3,1,1],'Test multilevel')
}
5.2 Buscar valores de global
Obtenha os valores globais do Python diretamente usando os subscritos ou o método get.
ClassMethod GetGlobal() [ Language = python ]
{
import iris
#gets a global reference
g = iris.gref('^mybgl')
# get values
print(g[3,1,1])
print(g.get([2,1]))
print(g["95752455",1])
}
5.3 Travessia
order - Travessia do global é essencial para coletar múltiplos níveis de dados do global. Esta função order do Python embutido funciona de forma semelhante ao comando $Order, utilizando a função order do iris.gref. Inicialmente, é necessário estabelecer uma referência à entidade global que requer travessia.
Travessia de nível de subscrito único
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:
break
print(f'{key} {g.get([key])}')
}
Percurso em níveis com múltiplos índices
zw ^mygbl^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= ''
while True:
key1 = g.order([key1])
if key1== None:
break
key2 = ''
while True:
key2 = g.order([key1,key2])
if key2 == None:
break
value = g.get([key1,key2])
print(key1,key2,value)
}
query
- Função de consulta a partir do iris.gref
semelhante a$query. sta função coleta todos os valores globais em tuplas. O resultado da tupla contém os IDs em uma lista e os valores na próxima tupla. Você pode consultar o exemplo de tupla abaixo.
ex:
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()
for x in key:
print(x)
}
data - Esta funçãodata
verifica se o subscrito fornecido existe no escopo global e retorna os valores de $data
usando a própria função de dados.
ClassMethod DollarData() [ Language = python ]
{
import iris
g = iris.gref('^mygbl')
key1= ''
print(g.data([1]))
}
6. Rotinas
Além disso, é essencial implementar os membros da classe. Devemos executar as rotinas como parte da implementação para sistemas com base de código legado e outras situações relacionadas. Consequentemente, existe uma função dedicada dentro do pacote da biblioteca iris que permite a invocação de rotinas a partir do Python embutido através do uso da função routine.
myirispython
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 as write $$add^myirispython(1,2)
}
Além disso, você também pode executar a rotina usando a função execute. iris.execute('do ^myirispython')
note: If the routine is not found
>>> iris.routine('^myirispythonT')
Traceback (most recent call last):
File "<input>", line 1, in <module>
RuntimeError: Routine not found
Continuaremos os outros tópicos no próximo artigo.