When using standard SQL or the object layer in InterSystems IRIS, metadata consistency is usually maintained through built-in validation and type enforcement. However, legacy systems that bypass these layers—directly accessing globals—can introduce subtle and serious inconsistencies.

InterSystems FAQ rubric

When exporting using the Export() method of the %Library.Global class, if the export format (fourth argument: OutputFormat) is set to 7, "Block format/Caché block format (%GOF)," mapped globals cannot be exported (only globals in the default global database of the namespace are exported). To export mapped globals in "Block format/Caché block format (%GOF)," specify the database directory to which you want to map them in the first parameter of %Library.Global.Export().

An example of execution is shown below. 

The 2025.1.2 and 2024.1.5 maintenance releases of InterSystems IRIS^® data platform, InterSystems IRIS^® for Health^TM, and HealthShare^® Health Connect are now Generally Available (GA). These releases include the fixes for a number of recently issued alerts and advisories, including the following: 

Hello community,

I wanted to share my experience about working on Large Data projects. Over the years, I have had the opportunity to handle massive patient data, payor data and transactional logs while working in an hospital industry. I have had the chance to build huge reports which had to be written using advanced logics fetching data across multiple tables whose indexing was not helping me write efficient code.

Here is what I have learned about managing large data efficiently.

Choosing the right data access method.

As we all here in the community are aware of, IRIS provides multiple ways to access data. Choosing the right method, depends on the requirement.

• Direct Global Access: Fastest for bulk read/write operations. For example, if i have to traverse through indexes and fetch patient data, I can loop through the globals to process millions of records. This will save a lot of time.

Set ToDate=+HSet FromDate=+$H-1ForSet FromDate=$O(^PatientD("Date",FromDate)) Quit:FromDate>ToDate  Do
. Set PatId=""ForSet PatId=$Order(^PatientD("Date",FromDate,PatID)) Quit:PatId=""Do
. . Write$Get(^PatientD("Date",FromDate,PatID)),!

• Using SQL: Useful for reporting or analytical requirements, though slower for huge data sets.

Starting out with ObjectScript, it is really exciting, but it can also feel a little unusual if you're used to other languages. Many beginners trip over the same hurdles, so here are a few "gotchas" you'll want to watch out for. (Also few friendly tips to avoid them)

NAMING THINGS RANDOMLY

We have all been guilty of naming something Test1 or MyClass just to move on quickly. But once your project grows, these names become a nightmare. 

➡ Pick clear, consistent names from the start. Think of it as leaving breadcrumbs for your future self and your teammates.

MIXING UP GLOBALS AND VARIABLES

Hi Team, 

Can I please check if anyone has built a simple web interface for maintaining custom SQL lookup class.   

We have a simple persistent class in HealthShare which is used for storing Pathology test codes. Test codes in this lookup class is used for message filtering and applying additional logic when processing pathology results/orders. 

We want to make this class available to external users from pathology (not the usual management portal users) to maintain so that they can add/edit/delete test codes as required. 

I joined InterSystems less than a year ago. Diving into ObjectScript and IRIS was exciting, but also full of small surprises that tripped me up at the beginning. In this article I collect the most common mistakes I, and many new colleagues, make, explain why they happen, and show concrete examples and practical fixes. My goal is to help other new developers save time and avoid the same bumps in the road.

1. Getting lost among system classes and where to start

While starting with Intersystems IRIS or Cache, developers often encounter three core concepts: Dynamic Objects, Globals & Relational Table. Each has its role in building scalable and maintainable solutions. In this article, we'll walk through practical code examples, highlight best practices, and show how these concepts tie together. 

1. Working with Dynamic Objects:

Dynamic objects (%DynamicObject and %DynamicArray) allow developers to manipulate JSON-like structures directly in Objectscript. They are especially useful for modern applications that need to parse, transform or generate JSON.

Trying to create a new SQL Storage map on existing cache Global in the following format - ^MYGLO("R",rec)=data where the 'data' is built using $zel. e.g. $zel(data,1)="p1", $zel(data,2)="p2" etc... and the ^MYGLO("R",123)=data.

I'm having 2 issues. First, using the SQL Storage map wizard, I cannot figure out how to convey data in $zel format in the "Delimiter" field. 

Second, since I couldn't figure that out,  I tried to use the "Use Retrieval Code" option and entered the following line for the P1 property:

but get an error when compiling saying I cannot reference another field:

Hey everyone,

I'm diving deeper into Caché ObjectScript and would love to open a discussion around the most useful tips, tricks, and best practices you’ve learned or discovered while working with it.

Whether you're an experienced developer or just getting started, ObjectScript has its own set of quirks and powerful features—some well-documented, others hidden gems. I’m looking to compile a helpful set of ideas from the community.

Some areas I’m especially interested in:

InterSystems has released new point updates to resolve a defect affecting the most recent prior versions of 2025.1.0, 2024.1.4, 2023.1.6, and 2022.1.7, for the following supported product lines:

• InterSystems IRIS
• InterSystems IRIS for Health
• HealthShare Health Connect

This issue could result in unexpected <PROTECT> errors or access anomalies when using features such as:

• Implied namespaces
• Mixed read-only/read-write access to databases
• Management Portal pages for listing routines and globals

Symptoms Included:

Summary

Hi IRIS experts!

I have a parameter in a class that stores a global name:

Parameter GlobalName = "^AGlobal";

then I'm trying to call it as:

set gn=$name(..#GlobalName)

to use it later as:

set @gn@("index")="value"

But! I'm having syntax at set gn=$name(..#GlobalName)

What am I doing wrong?

Introduction

Hello! In this article, I will be discussing database degrade, a type of data integrity issue one can face when using IRIS. First, I will be going over a review of the structure of IRIS databases. I'll then discuss how database degrade can manifest and common causes of degrade issues. I'll then conclude with general tips we give our customers about how to prevent or prepare for database degrade issues.

IRIS Database Structure

What exactly is a database? An IRIS database is a single file that consists of a fundamental unit called the "block". It contains a number of equally-sized blocks (typically 8kb) in sequential order. These blocks all "point" to each other by storing the offset in the database at which the block they point to resides. This network of blocks forms a configuration resembling a "forest" of what are called Balanced trees, or B-trees. Each global is represented by a separate B-tree, and each B-tree is accessible through a top-level Global Directory Block which holds pointers to all the global B-trees in the database.

The B-tree's defining feature is that all the "leaf"-level data blocks are on the same level. This means that anytime a top-pointer block fills up, another pointer layer is added above it, theoretically allowing the B-tree to scale indefinitely. At the beginning of each block, there are a number of bytes that indicate some metadata about that block and the blocks around it. For example, each block contains information about its block number, the number of bytes of data in the block, the type of block it is (pointer or data), the collation, etc. The block also contains information about related blocks, such as the block number of the block on its right, the first node of the block to its right, and the byte differences between the last node of the block and the block to the right.

Here is an example representation of what a global B-tree looks like. The green lines represent pointers between different levels of blocks, and the orange lines represent pointers between blocks and their neighboring block to the right. A block to the right value of 0 is used when the block is at the right edge of the tree.

Database Degrade

Database integrity issues occur when a database's internal structure either has some logical inconsistency, or the database does not match the form that IRIS expects. This can happen in a number of ways:

• Referential Integrity: The pointers between pointer blocks and data blocks, or the right-direction pointers between data blocks, are inconsistent. For example, a pointer block may indicate the first node of a data block it points to is ^x(10), while that data block's first node is actually ^x(20)
• Data Integrity: The data of the pointer or data blocks are corrupted. For example, the first few bytes of each block contains some metadata about the block itself and its related blocks, starting at offset 0. If these are located at some other offset, this would result in the block being corrupted.
• Application Integrity: This occurs when the database looks as IRIS expects, but there is some logical inconsistency related to how the application should look. For example, say we expect all doctor data to be saved in the ^Hospital.DoctorsD global, and indices on these doctors to be saved in ^Hospiral.DoctorsI. If a doctor had their data in the data global, but didn't have a corresponding index in the indices global, this would be a form of an application integrity issue.

Common causes of Degrade

Here, I'll be going over some of the common causes of database degrade we see from our customers.

Windows Write Caching

Windows write caching is a feature in Windows which can lead to database degrade issues. The idea behind this setting is that Windows will buffer disk writes in memory, and write them out to disk in larger packages. This helps improve performance in certain cases, as disk writes are slow, and doing them in larger packages allows for more efficient writing. For example, imagine your disk is broken up into 1024 byte blocks, and you have an application trying to write 256 4-byte chunks of data. Instead of doing 256 separate disk writes, which would be quite slow, write caching saves time by storing these writes in memory and writing them far less often.

However, this can create issues when power loss is involved. If the OS is storing data in memory that would normally have already been written out to disk, a loss in power can cause this data to be lost and unrecoverable, since RAM memory is volatile. For this reason, we often recommend our customers turn off Windows write caching when it is not necessary.

Hardware Write Caching

Just as OSes will use RAM to cache writes to disk, some enterprise-level disk drives will also cache disk writes for efficiency purposes. Certain SSDs for example contain a DRAM buffer which can store writes in order to write them in large packages for performance increases. Unfortunately, just as with OS-level write caching, DRAM and hardware memory in general is volatile, and will not be preserved in the case of power loss. This can be mitigated by ensuring the disk drive is powered by batteries or some other form of Uninterruptable Power Supply (UPS) so that it can flush the memory buffer in the event of a power failure.

VMware

VMware is a cloud hosting solution many of our customers use to run our products. There have been a number of known issues with VMware that can lead to data integrity issues. These are detailed in the following advisories:

• Advisory: VMWare vSAN and Data Integrity (link) : There is a known issue concerning disk extend operations with VMs running VMware vSAN, a storage solution offered by VMware
• Advisory: VMWare vSphere and Data Integrity (link) : SEsparse, a snapshot format for VMware machines, has a known data integrity issue
• Advisory: VMware vSAN Data Consistency Errors (link) : There are certain x86 instructions in the AVX-512 instruction set that can lead to data integrity issues when used with vSAN

General Advice

Here are some general recommendations we provide to our customers when helping them recover from database degrade issues.

Backups

When dealing with database degrade issues, our first recourse is surprisingly not to try and repair. Repairing databases by hand can be a cumbersome and not often fruitful process, due to the large scale and complexity of typical degrade issues. Instead, we will initially try to recover from a backup to restore the database to a healthy state. For this reason, we ask our customers to take frequent backups.

Backups are also highly useful for performing Root Cause Analysis (RCA) on why the degrade occurred in the first place. With a backup, we can see what the healthy state looked like for comparison with the unhealthy state. We can also see how the degrade changed or spread over time to track down its source.

Guide to doing backups: link

Integrity checks

It is vital for RCA that we catch database degrade as soon as possible. This is important because often degrade happens due to some aspect of the system state, whether that's on the application, OS, or hardware level.

For this reason, we ask our customers to run frequent checks of the ^Integrity routine. This routine checks databases and globals to verify that they have the format expected by IRIS. If you find there is degrade present in your databases, you can immediately contact the WRC and we can assist you in repairing and then conducting RCA to find the root cause.

Guide to running integrity checks: link

It is also important to run integrity checks outside of IRIS on the operation system and hardware that the IRIS instance is running on, as IRIS works inextricably with the OS and hardware in order to manage data correctly. This can be done through OS utilities such as fsck (UNIX) and chkdsk (Windows).

Conclusion

In the world of modern storage devices and advanced operating systems, data integrity issues are not as frequent as they once were. However they do still occur, and can lead to serious issues with application availability and data loss when they do. For this purpose, we ask our customers to frequently check the integrity of their data and systems, and contact us whenever they see an issue, so we can help restore their systems to working order as soon as possible. Thank you!

Hello Community,

When I run the following code with x undefined in terminal, it throws a syntax error and returns control to the program stack. After issuing a GO command, execution continues, and setting the global variable ^zz1.

code 1:

test.mac
if$Data(@x@(a,b,c)) {
    set^zz1=1212
}
write !,1212,!
////orif$Data(@x@(a,b,c)) set^zz1=1212write !,1212,!

 if I assign the result of $D(@x@(a,b,c)) to a local variable like d using set d=$D(@x@(a,b,c)), and then use if d { ... }, the code fails(global is not set) working as expected.

Code 2

Hello Community,

I have a queue that I need to traverse and perform operations on. To distribute the workload across multiple processes, I used a Work Queue Manager do process and I'm not expecting any status from it So, I skipped Sync / WaitForComplete in my implementation

I have the class ConfigUtils.ConfigSettingsTable, which is a persistent object.  I know I need to map packages from the original namespace. In this case, I have mapped ConfigUtils.ConfigSettingsTable from the originating namespace (IRISTST database) across all other namespaces.

With this, I am able to see the table ConfigUtils.InstanceSettings in SQL Explorer in each namespace, but the same data is not shared across environments. For example, in the MAINTENANCE namespace, I can see the table, but I don't see the same information that I see in the table in the original IRISTST namespace.

Hello Community,

The subroutine ^routine is not executed while the queue is being processed in WorkMgr. However, it works when defined as a function. Is it mandatory to define subroutine^routine as a function for it to execute properly?

Parallel query hinting boosts certain query performances on multi-processor systems via parallel processing. The SQL optimizer determines when this is beneficial. On single-processor systems, this hint has no effect.

Parallel processing can be managed by:

1.  Setting the auto parallel option system-wide.
   

2. Using the %PARALLEL keyword in the FROM clause of specific queries.
   

%PARALLEL is ignored when it applied to:

1. INSERT, UPDATE, and DELETE queries (Only SELECT queries benefit from this feature)
2. The queries involving process-specific functions or variables
3. A subquery correlated with an enclosing query.
4. A subquery containing complex predicates, such as FOR SOME and FOR SOME %ELEMENT predicates.

Here are some reasons why Parallel Query Processing might be ignored, in addition to the previously mentioned ones:

• Some complex queries may not benefit from parallel processing, even if they appear to do so initially.
• Certain database configurations and settings may not support %PARALLEL processing.
• Dependencies and relationships within the data structure could prevent effective parallelization.

%PARALLEL will not perform parallel processing in these scenarios:

1.  Query includes both TOP and ORDER BY clauses, optimizing for fastest time-to-first-row.
   

2.  Query references a view and returns a view ID.
   

3.  Query uses customized storage formats or GLOBAL TEMPORARY tables or tables with extended global reference storage.
   

4.  Query accesses a table with row-level security.
   

5.  Data is stored in a remote database.
   

6.  Process-level NLS collation doesn't match the NLS collation of all globals involved.
   

For more detailed options, considerations, and restrictions, refer to Configure Parallel Query Processing (Interystems Documentation) and Specify Optimization Hints in Queries. This topic was recently explored on top of a discussion in InterSystems Developer Community (DC), which inspired this article on IRIS, Caché, and Ensemble.

InterSystems IRIS supports parallel processing for both embedded SQL, dynamic SQL and SQL in QueryMethods. When the %PARALLEL keyword is being used in the FROM clause of a query to suggest parallel processing. The SQL optimizer will determine if the query can benefit from parallel processing and apply it where appropriate.

To utilize %PARALLEL processing in InterSystems IRIS effectively, several factors and limitations are needs to be considered for both system-wide and query-level settings to extract the full benefit.

In case of trying to achieve %PARALLEL processing with help of System-Wide Parallel Query Processing and Adaptive Mode is off, you can enable system-wide parallel query processing through Management Portal or $SYSTEM.SQL.Util.SetOption() Example

USER>w ##class(%SYSTEM.SQL.Util).GetOption("AutoParallel")
0
USER>d ##class(%SYSTEM.SQL.Util).SetOption("AutoParallel",1,.oldParVal)
 
USER>w ##class(%SYSTEM.SQL.Util).GetOption("AutoParallel")
1
USER>zw oldParVal
oldParVal=0

Other Important points to consider during the implementation of the %PARALLEL feature.

•   When [AdaptiveMode](https://docs.intersystems.com/iris20242/csp/docbook/DocBook.UI.Page.cls?KEY=RACS_AdaptiveMode) is enabled, automatic parallel processing is applied to all SELECT queries, hinting them with %PARALLEL. However, not all queries may use parallel processing as the SQL Optimizer may decide otherwise.
  

•   When we are trying to utilize this %PARALLEL feature, we must consider  [AutoParallelThreshold](https://docs.intersystems.com/iris20242/csp/docbook/Doc.View.cls?KEY=RACS_AutoParallelThreshold) as well (default value is 3200) and there is no use with this parameter in case [AutoParallel](https://docs.intersystems.com/iris20242/csp/docbook/DocBook.UI.Page.cls?KEY=RACS_AutoParallel) is disabled.
  

•   The auto parallel threshold parameter affects whether a query runs in parallel, with higher values reducing the chance of parallel processing. The default value is 3200, adjustable via $SYSTEM.SQL.Util.SetOption("AutoParallelThreshold",n,.oldval).
  

•   In sharded environments, parallel processing is used for all queries regardless of the threshold when Adaptive Mode is on.
  

•   When AdaptiveMode Mode is enabled (set to 1) and AutoParallel is disabled, Adaptive Mode overrides the AutoParallel setting and activates parallel processing.
  

Example: Sample class with populated 100,000 records

 Class SQLClass.MyTest Extends (%Persistent, %Populate)
  {
    
    Property Name As %String(MAXLEN = 255);
    
    Property Age As %Integer(MAXVAL = 100, MINVAL = 1);
    
    Property Address As %String(MAXLEN = 255);
    
    Property City As %String(MAXLEN = 255);
    
    Property State As %String(MAXLEN = 255);
    
    Property Zip As %String(MAXLEN = 255);
    
    Property Country As %String(MAXLEN = 255);
    
    Property Comment As %String(MAXLEN = 255);
    
    Property Hobby As %String(MAXLEN = 255);
    
    Property JobTitle As %String(MAXLEN = 255);
    
    Property Company As %String(MAXLEN = 255);
    
    Property PhoneNumber As %String(MAXLEN = 255);
    
    Property Email As %String(MAXLEN = 255);
    
    Property Gender As %String(MAXLEN = 1);
    
    Property Ethnicity As %String(MAXLEN = 255);
    
    Property Race As %String(MAXLEN = 255);
    
    Property Religion As %String(MAXLEN = 255);
    
    Property MaritalStatus As %String(MAXLEN = 255);
    
    Property Children As %Integer(MAXVAL = 10, MINVAL = 0);
    
    Property Income As %Integer(MAXVAL = 100000, MINVAL = 0);
    
    Property Occupation As %String(MAXLEN = 255);
    
    Property Education As %String(MAXLEN = 255);
    
    Property HomePhone As %String(MAXLEN = 255);
    
    Property MobilePhone As %String(MAXLEN = 255);
    
    Property WorkPhone As %String(MAXLEN = 255);
    
    Property WorkEmail As %String(MAXLEN = 255);
    
    Property HomeEmail As %String(MAXLEN = 255);
    
    Property HomeAddress As %String(MAXLEN = 255);
    
    Property HomeCity As %String(MAXLEN = 255);
    
    Property HomeState As %String(MAXLEN = 255);
    
    Property HomeZip As %String(MAXLEN = 255);
    
    Property HomeCountry As %String(MAXLEN = 255);
    
    Property WorkAddress As %String(MAXLEN = 255);
    
    Property WorkCity As %String(MAXLEN = 255);
    
    Property WorkState As %String(MAXLEN = 255);
    
    Property WorkZip As %String(MAXLEN = 255);
    
    Property WorkCountry As %String(MAXLEN = 255);
    
    Property WorkPhoneNumber As %String(MAXLEN = 255);
    
    Property WorkMobilePhone As %String(MAXLEN = 255);
    
    Property WorkFax As %String(MAXLEN = 255);
    
    Property WorkWebsite As %String(MAXLEN = 255);
    
    Property WorkComments As %String(MAXLEN = 255);
    
    
    Index IdxAge On Age;
}

Test # 1Sample run without % PARALLEL (to display 10,000 records in SMP)

select * from SQLClass.MyTest where age>40

• 3.2069 seconds
• 10404 global references
• 3325407 commands executed

Sample run with %PARALLEL(to display 10,000 records in SMP)

select * from %PARALLEL SQLClass.MyTest where age>40

• 2.8681 seconds
• 10404 global references
• 3325407 commands executed

Test # 2 :Sample run without % PARALLEL (to display 1 record in SMP)

select COUNT(Children),MAX(Children),MIN(Children),AVG(Children) from SQLClass.MyTest where age>10

• 0.4037 seconds
• 46559 global references
• 1459936 commands executed

Sample run with %PARALLEL (to display 1 record in SMP)

select COUNT(Children),MAX(Children),MIN(Children),AVG(Children) from %PARALLEL SQLClass.MyTest where age>10

• 0.0845 seconds
• 46560 global references
• 1460418 commands executed

Example with embedded SQL

ClassMethod embeddedSQL() As %Status
{
    // w ##Class(SQLClass.MyTest).embeddedSQL()
    Set sc = $$$OK
    DO ClearBuffers^|"%SYS"|GLOBUFF()
    set stime=$p($zts,",",2)
    &sql(select COUNT(Children),MAX(Children),MIN(Children),AVG(Children) from SQLClass.MyTest where age>10)
    w:'SQLCODE "Without %Parallel : ",($p($zts,",",2)-stime),!
    DO ClearBuffers^|"%SYS"|GLOBUFF()
    set stime=$p($zts,",",2)
    &sql(select COUNT(Children),MAX(Children),MIN(Children),AVG(Children) from %PARALLEL SQLClass.MyTest where age>10)
    w:'SQLCODE "With %Parallel : ",($p($zts,",",2)-stime),!
    Return sc
}

Results (embedded SQL) : USER> D ##Class(SQLClass.MyTest).embeddedSQL() Removed 5466 blocks Without %Parallel : .355737 Removed 5217 blocks With %Parallel : .3407056

USER>

Example with dynamic SQL

ClassMethod dynamicSQL() As %Status
{
     // w ##Class(SQLClass.MyTest).dynamicSQL()
    Set sc = $$$OK
    DO ClearBuffers^|"%SYS"|GLOBUFF()
    set stime=$p($zts,",",2), recCnt=0
    Set rs=##class(%ResultSet).%New()
    Set sc=rs.Prepare("select COUNT(Children),MAX(Children),MIN(Children),AVG(Children) from SQLClass.MyTest where age>10")
    Set sc=rs.Execute()
    While(rs.Next()) {
	 	w "COUNT(Children) : ",rs.GetData(1),"; MAX(Children) : ",rs.GetData(2),"; MIN(Children) : ",rs.GetData(3),"; AVG(Children) : ",rs.GetData(4),!
    }
    w "Without %Parallel : ",($p($zts,",",2)-stime),!!!
    DO ClearBuffers^|"%SYS"|GLOBUFF()
    set stime=$p($zts,",",2), recCnt=0
    Set sc=rs.Prepare("select COUNT(Children),MAX(Children),MIN(Children),AVG(Children) from SQLClass.MyTest where age>10")
    Set sc=rs.Execute()
    While(rs.Next()) {
	 	w "COUNT(Children) : ",rs.GetData(1),"; MAX(Children) : ",rs.GetData(2),"; MIN(Children) : ",rs.GetData(3),"; AVG(Children) : ",rs.GetData(4),!
	}
    w "With %Parallel : ",($p($zts,",",2)-stime),!
    Return sc
}

Result (Dynamic SQL): USER>d ##Class(SQLClass.MyTest).dynamicSQL() Removed 22163 blocks COUNT(Children) : 89908; MAX(Children) : 10; MIN(Children) : 0; AVG(Children) : 5.021989144458780086 Without %Parallel : .4036913

Removed 5721 blocks COUNT(Children) : 89908; MAX(Children) : 10; MIN(Children) : 0; AVG(Children) : 5.021989144458780086 With %Parallel : .3693442

Hi Community,

Watch this short exercise in writing basic code snippets in InterSystems ObjectScript using Copilot in VSCode and the GPT-4.0 engine. This screencast covers "Hello, World," global manipulation, class creation, and building a simple REST API application.

>> Coding InterSystems ObjectScript with Copilot <<

🗣 Presenter: @Evgeny Shvarov, Senior Manager of Developer and Startup Programs, InterSystems

📌 The related code can be found here: objectscript-copilot-demo.

Hi Community,

Enjoy the new video on InterSystems Developers YouTube:

⏯ Globals in Embedded Python for Dummies

Hello Community,

Is it possible to track or determine where the global variable was set (routine or class) in a form of like label+offset^routine?

Regards,

Ashok

The best way to list, edit, save and delete globals is using an IDE. Now, it is possible if you use VSCode. It is also possible to save globals using yaml files. Perform the following steps:

1. Get an InterSystems IRIS instance and install the application iris-global-yaml: 

zpm:USER>install iris-global-yaml

2. If you just to want an InterSystems IRIS trial for tests git clone and run on docker:

git clone https://github.com/yurimarx/iris-global-yaml.git
docker-compose up -d --build

VSCode is the most used IDE in the world. It is strategic have more extensions for VSCode for InterSystems technologies to keep increasing the developer community.

My new app IRIS VSCode Global Editor is an excellent sample to learn how to create extensions to IRIS. You can check it on https://openexchange.intersystems.com/package/IRIS-Global-VSCode-Editor.

To be ready to create extensions for VSCode

From https://code.visualstudio.com/api/get-started/your-first-extension you have all steps to get ready, but I will detail here to you.

Hello, 

We noticed from the integrity logs that some of the namespaces in our integration engine are using large amount of space ( ~380GB ) for the global ^EnsHL7.Segment. 

We have culling implemented for large globals like MessageHeader and MessageBody.

Is it a standard process to implement culling for ^EnsHL7.Segment global and any idea about what will be the impact of adding culling to this global?

As the title suggests, I would like to programmatically export each HL7 schema category as XML, either as a stream object or to a file. How would I go about doing this?

As the title suggests, I would like to programmatically export each individual data lookup table as XML, either as a stream object or to a file. How would I go about doing this?