I made a utility for converting between Cache Lists and Arrays with Python Lists and Dictionaries.

Bi-directional. Ensures the keys are strings when going from Array keys to Dictionary keys.

https://github.com/alexatwoodhead/PyNow/blob/main/Py.Helper.xml

Also have an approach for storing (pickle) and retrieving Numpy arrays in IRIS Property Streams if that is of use.

// Hugging the Globals for a fast ride

set tableName="MyTableName"
set key=""
for {
    set key=$Order(^Ens.LookupTable(tableName,key),1,value)
    quit:key=""
    Write !,key,"=",value
}

// As export string method with delimiters ":" and ";"

 classmethod ExportTableAsString(tableName) as %String
{
  set (ret,key)=""
  for {
    set key=$Order(^Ens.LookupTable(tableName,key),1,value)
    quit:key=""
    set ret=ret_key_":"_value_";"
  }
  quit $E(ret,1,*-1)
}

// As export array method

classMethod ExportTableAsArray(tableName,OUTPUT ary)
{
  kill ary
  merge ary=^Ens.LookupTable(tableName)
}
----------------
do ##class(Someclass).ExportTableAsArray("MyTable", .ary)

// If you want to iterate over a slice of keys for example All keys prefixed with "Q" set tableName="MyTableName"

set (key,prefix)="Q"
for {
    set key=$Order(^Ens.LookupTable(tableName,key),1,value)
    quit:key=""
    quit:prefix'=$E(key)
    Write !,key,"=",value
}

// To confirm existence of a key in a lookup table

if $Data(^Ens.LookupTable(tableName,someKey)) {
  Write !,key,"=",^Ens.LookupTable(tableName,someKey)
}

// To dump the lookup table to terminal

zwrite ^Ens.LookupTable(tableName)

The top node of the LookupTable has a timestamp, so it is possible you could use this to setup / invalidate an external cache of lookup values.

Hope this gives some ideas.

Ompare can also be run against exports that had been re-imported to clean namespaces for profiling locally.

It won't help for comparing namespace mappings or SQL, but it could still do the Lookup table differencing for you.

The approach either GIT / Ompare for actual diff is one choice.

With regard to achieving an export, I would suggest to use Studio on the target Ensemble Instance to create a "Project" for exporting.

Then add the respective Classes, Routines, HL7, include, Rules and any other components.

For lookup tables if the version is too early for visibility of "LUT" types, these can be exported by manually adding for example: Ens.LookupTable("MyTableName").GBL to the project, for each lookup table.

If you have a project on the server it is less error prone and quicker to have an existing export project to add items next time.

When you import with studio to report instance / git instance, you will have opportunity to double check which items you do actually want to import.

Hope that helps.

Currently they seem to be stored under:
^%sqlcq([Namespace], "SMPQueryHistory", [Username], ...

This means there is no defined data node at this level, but there are subnodes defined. ( Where $Data == 10 )

Remove the ending bracket ")" in Global Explorer the page will display the subnodes. ie: "^ROUTINE("

To see all first keys in Global Explorer: ^ROUTINE()

Or with a comma display all first and second subkeys eg: ^Routine( , )

To see the line count for each Routine: ^ROUTINE( , , 0)

$Data helps programmatically test for a global reference:

0 == Global is not defined

1 == Is a data node only

10 == Has no Data, but has subnodes (~pointer)

11 == Both is a data node AND has subnodes

If unsure of how many subkeys a global might have, can use $Query to generically walk a sparse structure beginning to end.

An example using $Query: A one liner to walk every global node in ROUTINE, looking at each line for the word "test", case insensitive, and print both the global node location and content of the code to the terminal:

s a="^ROUTINE",find="test",q=$Q(@a@("")) f{s q=$Q(@q) q:q=""  s v=$ZCVT(@q,"L")  w:v[find !,q,!,"::",@q}

Hope this helps.

Hi Jude,

SELECT * FROM Test.Pattern
where ColumnABC %PATTERN '1"C"1(1"00",1"01",1"77")1"."1N'

Explanation:

• First Character is "C"
• Second and Third Character is one of "00", "01" or "77"
• Fourth Character is "." (dot)
• Fifth Character is numeric (0 -9)

If needing the full range between C00 to C77 then:

SELECT * FROM Test.Pattern
where ColumnABC %PATTERN '1"C"1(1(1"0",1"1",1"2",1"3",1"4",1"5",1"6")1N,1"7"1(1"0",1"1",1"2",1"3",1"4",1"5",1"6",1"7"))1"."1N'

• First Character is "C"
• Second and third character are from

Option 1 - Second character is "0" to "6"

                 Third character is numeric "0" to "9"

Option 2 - Second character is "7"

                 Third character is numeric "0" to "7"

• Fourth Character is "." (dot)
• Fifth Character is numeric (0 -9)

Some further notes. These patterns also work unmodified in IRIS Object Script so you might have code:

ClassMethod ProcessCodeInline(code) As %Boolean
{
      if code?1"C"1(1(1"0",1"1",1"2",1"3",1"4",1"5",1"6")1N,1"7"1(1"0",1"1",1"2",1"3",1"4",1"5",1"6",1"7"))1"."1N {
  Write !,"Matched code pattern"
} else {
  Write !,"No match of code pattern"
}
}

So same pattern for both your SQL and ObjectScript.

The pattern AND IF structure may get a bit visually daunting so you can use indirection operator "@" to move the pattern into a Class Parameter. This also allows you to reuse the same match expression but manage the expression in one place:

 Parameter codepattern = "1""C""1(1(1""0"",1""1"",1""2"",1""3"",1""4"",1""5"",1""6"")1N,1""7""1(1""0"",1""1"",1""2"",1""3"",1""4"",1""5"",1""6"",1""7""))1"".""1N"; 

ClassMethod ProcessCode(code) As %Boolean
{
 if code?@..#codepattern {
   Write !,"Matched code pattern" 
 } else {
   Write !,"No match of code pattern"
 }
}

If you see this double quoted pattern in parameter, code or in a configuration global, it is a clue it is applied in a pattern via indirection by the application.

 set ^matchme("LabFormat")="1""C""1(1(1""0"",1""1"",1""2"",1""3"",1""4"",1""5"",1""6"")1N,1""7""1(1""0"",1""1"",1""2"",1""3"",1""4"",1""5"",1""6"",1""7""))1"".""1N"
 if "C01.8"?@^matchme("LabFormat") Write !,"Matched code pattern"

Cheers,

Alex

Hi Martin,

If you have sudo access you could switch the user for the iris session command, then run command as before

For example:

cd /tmp
sudo -u irisowner iris session irisinstancename

OR even:

cd /tmp
sudo -u irisusr iris session irisinstancename

Hope this helps.

Cheers,

Alex

Hi Ravi,

Variables that start with "%" for example %request, %session and %request may be in scope from adapter interactions. Otherwise the Adaptor helpfully adds a lot to the Stream Attributes

The following may give ideas for Headers available:

Class Test.HTTP.Service Extends EnsLib.HTTP.Service
{
Parameter ADAPTER = "EnsLib.HTTP.InboundAdapter";
Method OnProcessInput(pInput As %Stream.Object, Output pOutput As %Stream.Object) As %Status
{
#dim %request as %CSP.Request
set pOutput=##class(%Stream.TmpCharacter).%New()
do pOutput.Write("<p>AUTH:"_%session.HttpAuthorization_"</p>")
do pOutput.Write("</hr>")
set attribute=""
for {
set attribute=$Order(pInput.Attributes(attribute),1,data)
quit:attribute="" do pOutput.Write("attribute:"_attribute_" was "_data_"</br>")
}
do pOutput.Write("<hr/>")
set attribute=""
for {
set attribute=$O(%request.CgiEnvs(attribute),1,data)
quit:attribute="" do pOutput.Write("attribute:"_attribute_" was "_data_"</br>")
}
do pOutput.Write("</hr>")
do pOutput.Write("<p>Username:"_$USERNAME_"</p>")
do pOutput.Rewind()
Quit $$$OK
} }

Accessed with Enable-Standard-Resuests=True. With request sent to CSP Application with password authentication.

http://localhost:[portnumber]/csp/healthshare/[namespace]/Test.HTTP.Ser…

Where "TestHTTP" was the Production Item name.

Couldn't see the AUTH Header BUT can see the resulting validated Username in $USERNAME special variable.

Hope this gives some ideas.

Cheers,

Alex

Hi João,

I took your example for a drive. The source files and code are very useful to investigate the issue.

The sample document basicTemplate.jxml seemed to be incompatible with the schema. Which maybe why the schema validation step is not happy.

Locally the reports schema was imported to package "jr" and components imported to package "c". Then I needed to make the following enhancements to some of the generated classes.

Modified: jr.componentElement
// Commented out
// Property component As jr.componentType(XMLNAME = "component", XMLREF = 1) [ Required ];
// Needed to manually add:
Property list As c.list;
Property barbecue As c.barbecue;
Property Codabar As c.Codabar;
Property Code128 As c.Barcode4JCode128;
Property EAN128 As c.EAN128;
Property DataMatrix As c.DataMatrix;
Property Code39 As c.Code39;
Property Interleaved2Of5 As c.Interleaved2Of5;
Property UPCA As c.UPCA;
Property UPCE As c.EAN13;
Property EAN13 As c.EAN13;
Property EAN8 As c.EAN8;
Property RoyalMailCustomer As c.Barcode4JFourState;
Property USPSIntelligentMail As c.Barcode4JFourState;
Property POSTNET As c.POSTNET;
Property PDF417 As c.PDF417;
Property QRCode As c.QRCode;
Property map As c.map;
Property sort As c.sort;
Property table As c.table;
Property spiderChart As c.spiderChart;
Property iconLabel As c.iconLabel;

Class: c.table
Needed to manually add:
Property datasetRun As jr.datasetRun;

Class: c.column
Needed to manually add:
Property property As %String(MAXLEN = 220);

Class: c.TableCell
Needed to manually add:
Property box as jr.box;
Property staticText As jr.staticText;
Property property As %String(MAXLEN = 220);

My approach to figure this out was to respond to correlation errors like:

ERROR #6237: Unexpected tag in XML input: property (ending at line 64 character 71).Correlate status | 1

Where there was an unexpected element called "property" that didn't have a corresponding property in the generated class definition.

For componentElement I had replaced the tag "component" with distinct properties for each actual element name that would be encountered. I think if the sample document had used element name "component" instead of "jr.table" the XMLReader would have been able to determine what was needed. It seems to be a workable solution to adjust the generated classes slightly to fit the sample provided.

Hope this helps.

Cheers,

Alex

Hi Anna. I have written  a function to work for MAC, INT and INT generated from Classes, based on stack comment earlier. For user to test and confirm suitable for purpose :)

Usage from a class method or routine. Returns the line number. Arguments optional to capture other context.  

// how to call
set linenumber= ##class(DC.LineNumber).SrcLineNumberFromStack(.routine,.label,.offset,.src)
// debug
write !,"routine: ",routine
write !,"label: ",label
write !,"offset: ",offset
write !,"linenumber: ",linenumber
write !,"src:",src

Implementation:

Class DC.LineNumber [ Abstract ]
{ 
ClassMethod SrcLineNumber(routine As %String, label As %String, offset As %Integer = 0, Output src) As %Integer
{
if '$Data(^rMAC(routine)),$Data(^ROUTINE(routine)) {
// INT code only possibly generated
set globref="^ROUTINE" 
} else {
set globref="^rMAC" 
}
set labelLen=$Length(label)
set line=0
for {
// Try use rMAC if available as ROUTINE may have subsequent imported includes changing original line offsets
set line=$Order(@globref@(routine,0,line),1,data)
// reached the end of the routine
quit:line=""
set matchTest=$Extract(data,1,labelLen)
// discard non-matching lines
continue:$Extract(data,1,labelLen)'=label
// Looking for an exact match eg: Myline
// skip linelabels with prefix same as exact line label
// eg: MyLableBefore, MyLableAfter
// ie comprised by following alphanumeric character 
continue:$Extract(data,labelLen+1)?1AN
// Found the line so quit here
quit:matchTest=label
}
set line=line+offset
set src=$Select(line>0:$Get(@globref@(routine,0,line)),1:"")
quit line
}
/// Unpack current location
ClassMethod SrcLineNumberFromStack(Output routine As %String, Output label As %Integer, Output offset As %Integer, Output src As %String) As %Integer
{
quit:$Stack=1 0
set place=$Stack(($Stack)-1,"PLACE")
set routine=$Piece($Piece(place,"^",2)," ")
set offset=+$P($Piece(place,"^"),"+",2)
set label=$P($Piece(place,"^"),"+")
set line=(..SrcLineNumber(routine,label,offset,.src))
quit line
}

To clear a range of user tasks had used similar to:

for i=14:1:17 {do ##class(%SYS.Task).%DeleteId(i)}