Skip to main content

Learning
Documentation
Community
Open Exchange
Global Masters
Certification
Partner Directory

Sorry, your browser does not support JavaScript or JavaScript is disabled. Please enable JavaScript or use another browser to have a better experience.

InterSystems IRIS for Health 2025.1
Analytics and Data Science
Machine Learning
Using IntegratedML

InterSystems IRIS for Health 2025.1

Release Information

About...
Product Overview
Release Notes

New in 2025.1
New in 2024.3
New in 2024.2
New in 2024.1
New in 2023.3
New in 2023.2
New in 2023.1
New in 2022.3
New in 2022.2
New in 2022.1
New in 2021.2
New in 2021.1
New in 2020.1
New in 2019.1
Special Considerations When Upgrading
Known Issues
Deprecated & Discontinued

Supported Platforms

Supported Technologies
Supported Languages
Deprecated & Discontinued
Version Compatibility
Cross-Product Support

Releases and Prerelease Software
Licensing
Downloading Samples

Deployment

About...
Containers

About...
Container How-to
Deploy Right Now
Running in Containers
Deploying with Kubernetes

Installation Kit

About...
IRIS for Health Installation

Installing
Post-Installation Tasks
Upgrading
Create Foundation Namespace
Docker Considerations

Install on Windows

Overview
Pre-Install
Attended Install
Development
Server
Client
Web Server
Custom
Unattended Install
Post-Install

Install on UNIX, Linux, and macOS

Overview
Pre-Install
Attended Install
Development
Server
Custom
Client-only
Unattended Install
Post-Install

Installation Details

All Platforms

Installation Directory
Setup Types
Character Width Setting
Port Numbers
Installer Manifests
Configure Multiple Instances
Change Your Language
Web Server Troubleshooting

Windows

User Accounts
Web Server
Command Line Reference
Auto-start
The Write-cache Buffer

UNIX®, Linux, and macOS

AIX®
Red Hat Linux
SUSE
Ubuntu
Web Server
Owners & Groups
Nonroot User Install
Install Parameters
Install Packages
Starting InterSystems IRIS
macOS Concurrent Processes
Development Evironments
UNIX® Install Packages

Upgrading and Modifying

Upgrade Overview
Upgrading or Modifying on Windows
UNIX®, Linux, and macOS
Upgrading a Mirror
Upgrading ECP Configurations
Post-Upgrade Tasks

Configuration

About...
Resource Planning
Automating Configuration
Configuration Parameters (CPF)

CPF File Introduction
[Actions]
[Archives]
[ComPorts]
[config]
[ConfigFile]
[Databases]
[Debug]
[Devices]
[DeviceSubTypes]
[ECP]
[ECPServers]
[Gateways]
[IO]
[Journal]
[LicenseServers]
[Logging]
[Map]
[MapMirrors]
[MirrorMember]
[Mirrors]
[Miscellaneous]
[Monitor]
[Namespaces]
[SQL]
[SqlSysDatatypes]
[SqlUserDatatypes]
[Startup]
[Telnet]
[WorkQueues]

Data Migration

About...
Server Migration
ISQL Migration

Using ISQL

TSQL Migration

Planning a Migration
Language Constructs
Language Elements
Commands
Settings
Functions
Variables
Stored Procedures

DataMove

Adding Compiled Code

Administration

About...
System Administration

Management Portal Introduction
System-Wide Settings
Configuring Namespaces
Namespace Mappings
Configuring Local Databases
Configuring Remote Databases
Using Resources
Privileges and Permissions
Roles
User Accounts
Applications
Configuring TLS
Managing Superservers
Support for OAuth 2.0 & OpenID Connect
Task Manager Email
National Language Support
Work Queue Manager
Local Databases
Managing Processes
Managing Services
Scheduling Tasks
Background Tasks
Licensing
Managing on Windows
Managing on UNIX®, Linux & macOS
Connecting to Remote Servers
The iris Command
Third Party Software
Feature Tracker

Monitoring

About...
Monitoring Guide

Management Portal
Diagnostic Report
Log Monitor
Introduction to System Monitor Tools
System Monitor
Health Monitor
Application Monitor
^GLOSTAT
^PERFMON
^PROFILE
^%SYS.MONLBL
^TRACE
^SystemPerformance
^mgstat
History Monitor
^BLKCOL
^PERFSAMPLE
Structured Logging
SNMP
WS-Management
REST API for Metrics
irisstat Diagnostics

Emit OpenTelemetry Signals
Error Reference

General Error Messages
SQL Error Messages
TSQL Error Messages
System Error Messages
Messages Related to Productions

Operations

Create a Monitoring Plan
Tasks by Category
Tasks by Frequency
Tasks by Role
How to Troubleshoot
Task Reference

Managing the Registries

Service Registry
OIDs
Assigning Authorities
Configuration Keys
XUA
Trusted RSA Keys
Coded Entries

HL7 Productivity Tools

HL7 Message Analyzer
HL7 Production Generator
HL7 Migration Tool
HL7 DTL Generator

Production Validator
Special Tools & Utilities

Localization
Startup & Shutdown
Extending Languages
Windows Client Control
Fast Global Copy
Using Switches
Managing via Routines
Command-Line Security Management Utilities
Process Management
Byte Order Conversion
Convert FileMan to Class

Architecture

About...
Mirroring and High Availability

About...
High Availability Solutions
Data Resiliency
High Availability Guide

Failover Strategies
Mirroring Overview
Architecture & Planning
Configuring Mirroring
Managing Mirroring
Mirror Outage Procedures

Scalability

About...
Basics: Distributed Caching
Demo: Sharding
Scalability Guide

Overview
Distributed Caching
Deploy Cache Cluster
Cache Cluster Security
Monitor Cache Cluster
Develop Distributed App
ECP Recovery
Scale for Data Volume
Sharding Reference

Resiliency & Data Integrity

About...
Data Integrity Overview
Write Image Journaling
Backup and Restore
Journaling Overview
Configure Journaling
Basic Journaling Operations
Journaling Utilities
Journal I/O Errors
Special Considerations
Data Consistency Across Systems

Security

About...
Security Strategy
Auditing
Authentication
Authorization
Encryption
TLS
Security Reference

Securing Your Instance
Identity and Access Management
Encryption
TLS

Developer Tools

ObjectScript Shell

Introduction
Available Shells
Command History & Aliases
Customization

Windows Terminal

Basics
Connecting to Remote Hosts
Terminal Scripts
Script Command Reference
Customization
Running the Terminal Application from the Command Line
Advanced Topics

Connecting an IDE
Source Control Integration
Classes Page
Routines Page
Class Reference
Unit Testing with %UnitTest

About %UnitTest
Creating Unit Tests
Execute Unit Tests
Viewing %UnitTest Results

Scanning for Deprecated Code

Embedded Language Development

About...
Multiple Data Models
Orientation for Programmers

Introduction
Classes
Objects
Persistent Objects and InterSystems SQL
Namespaces and Databases
Security
Applications
Localization
Server Configuration Options
Useful Skills to Learn
Unicode Support
What’s That?

ObjectScript

About...
Using ObjectScript

Introduction
Syntax Basics
Procedure Syntax
Commands
Operators
Invoking Code & Passing Arguments
Variables
Process-Private Globals
Extended References
Multidimensional Arrays
Data Types
Numeric Values
Strings
Boolean Values
Lists
Bit Strings
Date & Time Values
Macros & Include Files
Embedded SQL
Locking & Concurrency
Details of Lock Requests and Deadlocks
Managing the Lock Table
%Status Values
Using TRY-CATCH
Error Logging
Command-Line Routine Debugging
(Legacy) Using ^%ETN for Error Logging
(Legacy) Traditional Error Processing
Legacy Forms of Subroutines

ObjectScript Reference

Symbols & Abbreviations
Operators
Commands
Routine & Debugging Commands
Functions
Special Variables
Structured System Variables
Macro Preprocessor Directives
Identifiers
General System Limits
System Macros
Flags & Qualifiers
Regular Expressions
Translation Tables
Numeric Computing

ObjectScript Tutorial

The Basics

Overview of the ObjectScript Tutorial
Class Methods
Terminal
VS Code - ObjectScript
Do Command
Class Methods and Routines
Method Details
Passing Arguments by Reference
Return and Quit Commands
Write Command
Read Command
Set Command
Operator Precedence
Syntax
Common Errors
Write (again) and Kill Commands
If Construct
Simple Conditions
Complex Conditions
Hands-On Exercise 1
Class Compilation
Controlling Execution Flow
$Case Function
For Construct
While and Do/While Constructs
Try/Catch Construct, and Throw Command
Multiple Purpose Characters
Hands-On Exercise 2
Recap of Part 1

The Good Stuff

Strings
Storing a String
Concatenation Operator
Pattern Matching and Regular Expressions
Pattern Matching Examples
String Functions
String Functions, continued
Lists
Compare Pieces and Lists
Setting Substrings, Pieces, and List Items
More List Functions
Bitstrings
Dates
Hands-On Exercise 3
JavaScript Object Notation (JSON)
Arrays
Ordered Trees
Ordered Trees, continued
Value and Existence, and the $Data Function
Viewing and Killing Arrays
Globals
$Increment and $Sequence Functions
Storage Method
Storage Method, continued
Example of Globals
Hands-On Exercise 4
Recap of Part 2

Using Globals

$Order Function
$Order Function, continued
Working With Indexes
$Order Loop
Nested $Order Loops
Starting Focused $Order Loops
Ending Focused $Order Loops
Hands-On Exercise 5
Conversion Functions
$Get Function
Hands-On Exercise 6
Database Integrity
Lock Command
Lock Command, continued
Lock Command and $Test
Transaction Processing
Hands-On Exercise 7
InterSystems IRIS Objects and SQL
Object Methods
Object Storage
SQL Queries
Recap Of Part 3

RightTriangle Example Class and Exercise Solutions

Right Triangle Example Class
Exercise 1: First Data Entry Class
Exercise 2: Second Data Entry Class
Exercise 3: Third Data Entry Class
Exercise 4: Storage Method
Exercise 5: First Lookup Class
Exercise 6: Second Lookup Class
Exercise 7: Third Lookup Class

Embedded Python

Intro to Embedded Python
Using Embedded Python

Introduction and Prerequisites
Install and Import Python Packages
Run Embedded Python
Call Embedded Python Code from ObjectScript
Call InterSystems IRIS from Embedded Python
Bridge the Gap Between ObjectScript and Embedded Python
Use Embedded Python in Interoperability Productions
Use the Flexible Python Runtime Feature
InterSystems IRIS Python Module Reference

Multidimensional Storage

Introduction
Formal Rules
Extended References
Mapping
Working with Globals
SQL & Objects
Temporary Globals
Management Portal Options
Global Sizes
Import/Export

Class Programming

Defining & Using Classes

Class Definition Reference

Introduction
Top Level Class Syntax and Keywords
Foreign Keys
Indices
Methods
Parameters
Projections
Properties
Queries
Triggers
XData
Storage

API Manager
SQL

About...
Using SQL

Using InterSystems SQL
InterSystems SQL Features
InterSystems SQL Basics
Language Elements
Implicit Joins (Arrow Syntax)
Identifiers
Using Embedded SQL
Using Dynamic SQL
Using the SQL Shell Interface
Using the Management Portal SQL Interface
Defining Tables
Defining and Using Views
Relationships Between Tables
Using Triggers
Collation
Federated Tables
Foreign Tables
Modifying the Database
Querying the Database
Defining and Using Stored Procedures
Storing and Using Stream Data (BLOBs and CLOBs)
SQL Users, Roles, and Privileges
Using Vector Search
SQL Settings Reference
Importing SQL Code
Importing and Exporting SQL Data

SQL Text Search

About SQL Search
Basics: SQL Search
Using SQL Search
SQL Search REST Interface

SQL Security
Optimizing SQL

SQL Performance Overview
How InterSystems IRIS Processes SQL Statements
Best Practices for Improving SQL Performance
Examine Query Performance

Analyze SQL Statements and Statistics
Interpreting an SQL Query Plan
SQL Performance Analysis Toolkit
Get SQL Performance Help

Defining a High-Performance Schema

Table Statistics for Query Optimizer
Define and Build Indexes
Choose an SQL Table Storage Layout
Define SQL Optimized Tables Through Persistent Classes

Configure SQL Performance Options

Configure Parallel Query Processing
Using Runtime Plan Choice
Configure Frozen Plans
Using Adaptive Mode to Improve Performance
Working with Cached Queries
Specify Optimization Hints in Queries

InterSystems SQL Reference

Symbols and Syntax Conventions
SQL Commands
SQL Clauses
SQL Predicate Conditions
SQL Aggregate Functions
SQL Window Functions
SQL Functions
SQL Unary Operators
SQL Reference Material

Using the InterSystems SQL Gateway

SQL Gateway Overview
Accessing a Database with the SQL Gateway
Connecting the SQL Gateway via JDBC
Connecting the SQL Gateway via ODBC
Using the SQL Gateway Programmatically

Document Database

Introducing InterSystems IRIS Document Database (DocDB)
Managing Documents
REST Client Methods

Web Applications & APIs

About...
Web Gateway

Introduction
Access Built-in Web Apps with Your Web Server
Setup Overview
Install a Standalone Web Gateway
Extend Your Web Server Configuration
Choose URL Paths to Route
Overview of the Web Gateway Management Pages
Define Server Access Profiles
Define Application Access Profiles
Configure System-Wide Parameters
Protecting Web Gateway Connections to InterSystems IRIS
Managing and Monitoring the Web Gateway
CGI Environment Variables Passed by the Web Gateway
HTTP Response Headers Returned by the Web Gateway
Compressing the Response to Requests for CSP Forms (GZIP/ZLIB)
Implementing HTTP Authentication for Web Applications
Load Balancing, Failover, and Mirrored Configurations
Process Affinity and State-Aware Mode (Preserve Mode 1)
Web Gateway Registry in InterSystems IRIS
CSP.ini Parameter Reference
Using the NSD (Windows)
Using the NSD (UNIX®/Linux/macOS)
Alternative Options for Apache (UNIX®/Linux/macOS)
Locked-Down Apache
Alternative Options for IIS 7 or Later (Windows)

Web Server Considerations

Apache Considerations (UNIX®/Linux/macOS)
IIS Considerations (Windows)

REST and JSON

About...
REST Services

Introduction to Creating REST Services
Creating and Editing REST Services
Modifying the Implementation Class
Modifying the Specification Class
Securing REST Services
Listing and Documenting REST APIs
/api/mgmnt/ API Endpoints
OpenAPI Properties in Use
Creating a REST Service Manually

Using JSON

Using JSON in ObjectScript
Creating and Modifying Dynamic Entities
Iteration and Sparse Arrays
Working with Datatypes
Converting Dynamic Entities to and from JSON
Using the JSON Adaptor
Quick Reference for Dynamic Entity Methods

WSGI
SOAP

About...
Web Services & Clients

Introduction
Creating Web Services
Message Variations
Creating Web Clients
Fault Handling
MTOM
SOAP with Attachments
Custom Headers
WS-Addressing
Sessions
Binary Format
Datasets
Troubleshooting
Summary of URLs
WSDL Details
Generated Classes

Web Service Options

Disabling Access to WSDL
Requiring a Username and Password
Controlling the XML Types
Controlling the Namespaces of the Schema and Types
Including Documentation for the Types
Adding Namespace Declarations to the SOAP Envelope
Checking for Required Elements and Attributes
Controlling the Form of Null String Arguments
Controlling the Message Name of the SOAP Response
Overriding the HTTP SOAP Action and Request Message Name
Specifying Whether Elements Are Qualified
Controlling Whether Message Parts Use Elements or Types
Controlling Use of the xsi:type Attribute
Controlling Use of Inline References in Encoded Format
Specifying the SOAP Envelope Prefix
Restricting the SOAP Versions Handled by a Web Service
Sending Responses Compressed by gzip
Defining a One-Way Web Method
Adding Line Breaks to Binary Data
Adding a Byte-Order Mark
Customizing the Timeout Period
Using Process-Private Globals to Support Very Large Messages
Customizing Callbacks of a Web Service
Specifying Custom Transport for a Web Service
Defining Custom Processing in a Web Service

Web Client Options

Modifying a Web Client
Disabling Keep-Alive for a Web Client
Controlling the Form of Null String Arguments
Controlling the Client Timeout
Using a Proxy Server
Setting HTTP Headers
Specifying the HTTP Version to Use
Disabling SSL Server Name Checking
Controlling Use of the xsi:type Attribute
Controlling Use of Inline References for Encoded Format
Specifying the Envelope Prefix
Adding Namespace Declarations to the SOAP Envelope
Sending Responses Compressed by gzip
Quoting the SOAP Action (SOAP 1.1 Only)
Treating HTTP Status 202 Like Status 200
Defining a One-Way Web Method
Adding Line Breaks to Binary Data
Adding a Byte-Order Mark
Using Process-Private Globals When Parsing
Creating Custom SOAP Messages
Specifying Custom HTTP Requests
Customizing Callbacks of a Web Client
Specifying Custom Transport from a Web Client
Specifying Flags for the SAX Parser
Using the WS-Security Login Feature
Using HTTP Authentication

SOAP Security

Securing Web Services with SOAP
Setup and Other Common Activities
Creating and Using Policies
WS-Policy Configuration Class Details
Adding Security Elements Manually
Adding Timestamps and Username Tokens
Encrypting the SOAP Body
Encrypting Security Header Elements
Adding Digital Signatures
Using Derived Key Tokens for Encryption and Signing
Combining Encryption and Signing
Validating and Decrypting Inbound Messages
Creating Secure Conversations
Using WS-ReliableMessaging
Creating and Adding SAML Tokens
Troubleshooting Security Problems
Details of the Security Elements

CSP

Introduction
Application Configuration
Creating a Page
Examining the Request
Managing Sessions
Ending Sessions
Cookies
Updating a Page without Reloading
Handling Errors
Controlling Access
Encryption
Localization
Authentication Sharing
Logging
Reserved URL Parameters
Special HTML Directives
CSP Error Codes

WebSockets

Other Available APIs

File & Directory API

What Is %Library.File?
Query Directories and Drives
File and Directory Properties and Attributes
File and Directory Names
Work with Directories
Work with Files
Work with the %File Object
%File Example

XML Tools

Introduction
Considerations When Using the XML Tools
Reading & Validating
Using %XML.TextReader
Importing into Objects
Representing as DOM
Writing XML from Objects (Basics)
Writing XML (Details)
Encryption
Signing
XPath Expressions
XSLT Transformations
Customizing Parser
Classes from Schemas
Schemas from Classes
Examining Namespaces and Classes
XML Standards
XML Background

XML Projections

Introduction to Object-XML Projections
Projecting Objects to XML
Controlling Transformations of Values
Handling Empty Strings and Null Values
Controlling the XML Element and Attribute Names
Specifying Namespaces for Elements and Attributes
Controlling the Projection to XML Schemas
Advanced Options for XML Schemas
Special Topics
Summary of XML Projection Parameters

Internet Utilities

HTTP Request
HTTP Response
Email Support
Creating Email Messages
Sending via SMTP
Retrieving via POP3
Working with Received Email
MIME
FTP
SSH
IBM WebSphere MQ

External Messaging Platforms

Using the Messaging APIs
JMS
Kafka
RabbitMQ
Amazon SNS
Amazon SQS

REST API for Source Code

Introduction
Tutorial
Reference

API Index

Tools Index

Other Topics

I/O Device Guide

Introduction to I/O
Principal Device, Current Device, and Null Device
Specifying Devices
Pipes
Communication Between InterSystems IRIS Processes
TCP
TCP Advanced Topics
UDP
Terminal I/O
Files
Spool Device
Printers
Controlling Devices with Mnemonic Spaces
Managing Devices and Mnemonic Spaces
Using ^%IS
Device Special Variables

Bits & Bitstrings
Semaphores
String Localization

Introduction
Message Dictionaries
Message Files
Managing Dictionaries

Process Memory
Work Queue Manager

Introduction
Code Requirements
Using the Work Queue Manager
Categories
Callbacks
Controlling Output
Pausing & Resuming
Detaching & Attaching
Stopping a Work Queue
Setup & Teardown
About Worker Jobs

Secure Logins

Glossary

Complete Glossary of Terms

External Language Development

About...
Native SDKs
Using InterSystems External Servers

Introduction to InterSystems External Servers
Working with External Languages
Managing External Server Connections
Customizing External Server Definitions
InterSystems External Server Requirements
Quick Reference for the ObjectScript $system.external Interface

Java

About...
JDBC for Relational Access
Demo: Connect with JDBC
Demo: Java and XEP
Using Java

Java with InterSystems Overview
InterSystems Java Connectivity Options
Using the JDBC Driver
Configuration and Requirements
JDBC Fundamentals
JDBC Quick Reference

Native SDK for Java

Introduction to the Java Native SDK
Calling ObjectScript Methods and Functions from Java
Using Java Inverse Proxy Objects
Working with Global Arrays
Transactions and Locking
Java Native SDK Quick Reference

Persisting Java Objects with Java Persister

The InterSystems Persister for Java
Overview of the Java Persister
Serializing Data with Persister
Implementing Schemas with SchemaManager
Designing Schemas with SchemaBuilder
Java Persister Examples
Quick Reference for Java Persister Classes

Persisting Java Objects with XEP

Using XEP with Java Overview
Introduction to XEP
Using XEP Event Persistence
XEP Quick Reference

InterSystems Implementation Reference for Third Party Software

Overview of Third Party Software
JDBC Driver Support
Python DB-API Support
Hibernate Support

.NET

About...
Demo: Connect with ADO.NET
Demo: .NET and XEP
Using .NET

Introduction to Using .NET with InterSystems Software
Connecting to the Database with .NET
.NET Requirements and Configuration
Using the ADO.NET Managed Provider
Quick Reference for the .NET Managed Provider

Native SDK for .NET

Native SDK for .NET Overview
Introduction to the .NET Native SDK
Calling ObjectScript Methods and Functions from .NET
Using .NET Inverse Proxy Objects
Working with Global Arrays in .NET
Transactions and Locking
Native SDK for .NET Quick Reference

Persisting .NET Objects with XEP

Introduction to XEP for .NET
Using XEP Event Persistence with .NET
Quick Reference for XEP .NET Classes

ODBC

About...
Using the InterSystems ODBC Driver

Document Overview
Getting Started
Defining an ODBC Data Source on Windows
Defining an ODBC Data Source on UNIX®
ODBC Installation and Validation on UNIX® Systems
ODBC Support for Python and Node.js
Logging and Environment Variables

Native SDK for Python

About...
Using the Native SDK for Python

Introduction to the Native SDK for Python
Calling Database Methods and Functions from Python
Controlling Database Objects from Python
Accessing Global Arrays with Python
Managing Transactions and Locking with Python
Using the Python DB-API
Native SDK for Python Quick Reference

Native SDK for Node.js

About...
Using the Native SDK for Node.js

Introduction to the Native SDK for Node.js
Calling ObjectScript Methods and Functions
Working with Global Arrays
Transactions and Locking
Native SDK Quick Reference for Node.js

Callin

The Callin Interface
Using the Callin Functions
Callin Function Reference

Callout

The InterSystems $ZF Callout Interface
Overview of the $ZF Callout Functions
Running Programs or System Commands with $ZF(-100)
Creating an InterSystems Callout Library
Invoking Callout Library Functions
InterSystems $ZF Callout Quick Reference

Connecting Systems

About...
Introducing Productions

Basics: Productions
Introduction to Interoperability Productions
Connectivity Options
Business Processes and Business Logic
Other Production Options

Preparing to Create Productions

Production Roadmap
Planning a Deployment

Production Best Practices

Best Practices for Production Development
Design Model for a Routing Production
Converting Interfaces to Production Elements
Managing Databases for Productions

Developing Productions

About...
ObjectScript Productions

Introduction
Coding Business Hosts
Defining Messages
Business Service Class
Business Process Class
Business Operation Class
Alert Processor
Data Transformations
Business Metrics
Enterprise Message Bank
Record Mapper
Complex Record Mapper
Record Map Batch
Other Development Tasks
Test and Debug
Deploy Production
Production Lifecycle

Java, Python, & .NET Productions

Introduction
Getting Started
About Business Hosts and Adapters
PEX Messaging
Inbound Adapters
PEX Outbound Adapters
Business Services
PEX Business Processes
PEX Business Operations
Registering a PEX Component
Connecting with External Language Servers
PEX API Reference

Business Logic

Developing BPL Processes

Introduction
Listing the Business Processes
Creating
Editing
Variables Available in BPL
BPL Syntax Rules
List of BPL Elements
Handling Errors in BPL
BPL Business Process Example

Developing DTL Transformations

DTL Tools
Introduction to the DTL Editor
Introduction to the New DTL Editor
Creating Data Transformations
Adding and Editing Actions
DTL Syntax Rules
Assign Actions
Other Actions
Listing & Managing
Testing

BPL and DTL Reference

BPL Elements
DTL Elements

Developing Business Rules

About Business Rules
Getting Started
Working with Rules
Debugging Routing Rules
Utility Functions for Use in Productions

Enterprise Service Bus

Enterprise Service Bus and Registry Overview
Accessing the Public Service Registry through the Public REST API
Administering the Public Service and External Service Registries
Configuring an ESB
Configuring ESB Services and Operations
Configuring an InterSystems IRIS System and Creating a Namespace
Configuring a Web Application for a Pass-through Business Service
Pass-through Service and Operation Walkthrough
Service Registry Public API Reference

Workflow

Overview
Developing a Workflow
Including Custom Features in a Workflow
Testing a Workflow
Exploring the Workflow Sample
Available Workflow Metrics

Push Notifications

Push Notifications Overview
Configuring and Using Push Notifications

Configuring and Managing Productions

About...
Configuring Productions

Introduction
Production Configuration Page
New Production Configuration Page
Creating a Production
Adding Business Hosts
Configuring Settings
Configuring Alerts
Defining Reusable Items for Use in Settings
Data Lookup Tables
System Default Settings
Interoperability Settings
Configuring a Mirror Virtual IP as the Network Interface
Enterprise Message Bank
Identifying Enterprise Systems for Viewing and Monitoring
Creating Dashboards
Settings Reference

Managing Productions

Introduction
Starting and Stopping
Deploying Productions
Purging Data
Using the Archive Manager
Managing Workflows
Publish and Subscribe
Controlling Data Storage
Security Roles and Resources
Menu Items

Monitoring Productions

Core Concepts When Monitoring Interoperability Productions
Monitoring All Namespaces
Monitoring a Production
Viewing, Searching, and Managing Messages
Event Log
Tracing
Business Rule Log
Business Process Instances
I/O Archive
Viewing Messages from Multiple Productions
Enterprise Message Viewer
Enterprise Message Bank
Interface Maps
Interface References
Alerts
Activity Volume
Port Usage

Testing Productions

Testing Productions Tutorial
Testing Productions

TestControl
Callback Methods
Auxiliary Methods
Parameters and Properties
Creating a Test - Summary
Executing a Test
Example Overview
Example: Example Production
Example: Production Test
Example: OnAfterProductionStart
Example: CheckResults
Example: CheckErrors
Example: Executing the Test
Recap

Creating Tutorial.ExampleOperation

Data Formats

About...
Virtual Documents

Introduction
Schema Definitions
Virtual Property Paths
Using Virtual Documents in a Production
Defining Search Tables
Message Validation
Custom Schema Categories
Portal Tools
Syntax Guide for Virtual Property Paths
Common Settings

Transforming Data
Tracing Errors
FHIR

About...
FHIR Concepts & Features

What is FHIR?
FHIR Components
FHIR Server: Architecture

FHIR SQL Builder

Introduction
Generate Schema
Access the Builder
Analyze Repo
Create Specification
Move Specification
Create Projection

Bulk FHIR Coordinator

Introduction
Bulk FHIR Home Page
Create a Configuration
Import a Configuration
Export FHIR in the App
Export FHIR with REST
Role-based Access
Create OAuth Server
BFC Setup Checklist

FHIR Standard Support

Supported Interactions
Supported Operations

Installing & Configuring

Install FHIR Server
Configure FHIR Server
Reset FHIR Server
Delete FHIR Endpoint
Configure Validation

Using a FHIR Server

Use a FHIR Client
Use Messages & Payloads
Use FHIR Data Model
Use FHIRPath
Write Custom Ops
Bypass the Client

Using FHIR in Productions

Use a FHIR Production
Transform Data
Use an Interop Adapter (no Repository)

Administering FHIR Servers

Use Profiles & Packages
Secure FHIR Server
Debug FHIR Server
Maintain FHIR Server
Customize FHIR Server

Supporting Legacy FHIR

Migration Steps
Migrate Data
Migrate Transforms
Migrate to JSON SQL

SDA

About SDA
SDA Documents
Customizing the SDA

CDA

XSL Transform Basics
Custom XSL Transforms
Preprocessing C-CDA 2.1
CDA/SDA Annotations

IHE

Introduction
IHE Integration Statement
PIX & PDQ Query
PIX Add
XDS Query & Retrieve
XDS.b Provide & Register
XCA
HL7 to C-CDA
SDA to C-CDA
C-CDA to SDA
XUA
IUA
XCA-I
Registry Settings
IHE Test Utility
Auditing

HL7 v2

Introduction
HL7 Schemas and Available Tools
Configuring the Production
Routing Rule Sets
DTL Data Transformations
Search Tables
Important HL7 Scenarios
Settings Reference

DICOM

Introduction
Creating DICOM Associations
Tasks for DICOM Productions
Sample DICOM Modality Worklist Production
Sample DICOM Routing to Storage Production
Sample DICOM File Storage Production
Sample DICOM Router Productions
DICOM Transfer Syntax
DICOM Glossary of Terms

ASTM

Introduction
Available Tools
Configuring the Production
Additional Steps
Settings Reference

NHS Toolkit

Overview
Setting Up the ITK Switchboard
Using the ITK Adapter Kit

EDIFACT

Introduction
Available Tools
Configuring the Production
Additional Steps
Settings Reference

X12

Introduction
Available Tools
Configuring the Production
Data Transformations
Handling X12 Interchanges
Settings Reference

XML Virtual Documents

Introduction
Available Tools
Configuring the Production
Virtual Property Paths
Schema-dependent Paths
DOM-style Paths
Data Transformations
Rule Sets
Search Tables
Classes for Use with XML Virtual Documents
Settings Reference
XML-Enabled Objects

Communication Protocols

Protocols & Adapters
Message Formats
Cloud Storage Adapters

Introduction
Inbound Adapter
Outbound Adapter
Settings Reference
APIs

CloudWatch Adapter
Amazon HealthLake

Introduction
Inbound Adapters
Using the HealthLake Business Operation
Outbound Adapter
Settings Reference

Email Adapters

Inbound Adapter
Outbound Adapter
Settings Reference

File Adapters

Inbound Adapter
Outbound Adapter
Passthrough Classes
Settings Reference

FTP Adapters

Inbound Adapter
Outbound Adapter
Settings Reference

HTTP Adapters

Introduction
Inbound Adapter
Outbound Adapter
Built-in HTTP Components
HTTP Adapter Settings

REST Services and Adapters

REST Services
REST Operations

SOAP Services and Web Clients

Introduction
Web Services
Web Clients
Configuring the Production
Inbound Adapter (Alternative)
Older Web Service Variation
Settings Reference

SAP Java Connector

Overview
Setup Tasks
Using the SAP Java Connector

SQL Adapters

Introduction
Using an SQL Business Service
Using an SQL Business Operation
More About Messages
More About Procedures
Custom SQL Business Services
Custom SQL Business Operations
Creating Adapter Methods
Using Result Sets (SQL Adapters)
Using Snapshots (SQL Adapters)

TCP Adapters

Inbound Adapters
Outbound Adapters
Special Topics
Settings Reference

Managed File Transfer

Introduction
Prerequisites & Configuration
Configuring the Production
MFT API

Messaging Platforms

External Messaging Platforms

Sending Amazon SNS Messages
Retrieving Amazon SQS Messages
Sending Amazon SQS Messages
Retrieving JMS Messages
Sending JMS Messages
Retrieving Kafka Messages
Sending Kafka Messages
Retrieving RabbitMQ Messages
Sending RabbitMQ Messages
Settings Reference

IBM WebSphere MQ

Introduction
Inbound Adapter
Outbound Adapter
Troubleshooting IBM WebSphere MQ Adapters
Settings Reference

MQTT

Introduction
MQTT Adapters
Passthrough
Settings Reference

JMS (Legacy)

JMS Overview (Legacy)
JMS Business Services & Operations (Legacy)
Custom JMS Services & Operations (Legacy)

Analytics and Data Science

About...
Business Intelligence

About...
BI Introduction

Introduction to Business Intelligence
Introduction to the Business Intelligence User Interfaces
Introduction to the Other Business Intelligence Tools
Business Intelligence Glossary

BI Modeling

Overview of InterSystems IRIS Business Intelligence Models
Basic Concepts
Summary of Model Options
Principles and Recommendations
Defining Models for InterSystems Business Intelligence
Compiling and Building Cubes
Defining Dimensions, Hierarchies, and Levels
Details of Defining Levels
Defining Properties
Defining Measures
Defining Listings
Defining Listing Fields
Defining Calculated Members
Defining a Named Set
Defining Subject Areas
Defining Listing Groups
Reference Information for Cube Classes
Reference Information for Subject Area Classes
Details for the Fact and Dimension Tables

BI Advanced Modeling

Defining Computed Dimensions
Defining Shared Dimensions and Compound Cubes
Defining Cube-Cube Relationships
Using Text Analytics in Cubes
Defining Term Lists
Defining Worksheets
Defining Quality Measures
Defining Basic KPIs
Defining KPIs with Filters and Listings
Defining Advanced KPIs
Defining Plug-ins
Using Cube Inheritance
Defining Intermediate Expressions
Other Options
Reference Information for KPI and Plug-in Classes
Generating Secondary Cubes for Use with Text Analytics

Using Dashboards and the User Portal

Introduction to the User Portal
Using the Portal Features
Orientation to Dashboards
Using Dashboards
Using the Pivot Analysis Window

BI Dashboards

Introduction to Dashboards
Creating and Modifying Dashboards
Specifying Common Widget Options
Adding Pivot Table Widgets
Adding Chart Widgets
Customizing the Appearance of a Chart Widget
Adding Meter Widgets
Adding Scorecard Widgets
Adding Other Widgets
Defining and Using Themes
Adding Widget Controls

Implementing InterSystems IRIS Business Intelligence

Overview of Business Intelligence
Initial Steps
Settings
Data Connectors
Performance Tips
Custom Actions
Accessing Dashboards from Your Application
Keeping the Cubes Current
Using Cube Synchronization
Using the Cube Manager
Executing Queries Programmatically
Localization
Packaging Business Intelligence Elements into Classes
Portlets
Additional Steps
Controlling Access
Cube Versions
How the Analytics Engine Works
MDX Performance Utility
Logging and Diagnostics
Other Export/Import Options
Disaster Recovery

BI Analyzer

Introduction to the Analyzer
Creating Pivot Tables
Filtering Pivot Tables
Defining Calculated Elements
Defining and Using Pivot Variables
Customizing Pivot Tables
Working with Pivot Tables
Performing Ad Hoc Analysis
Configuring InterSystems IRIS for PDF Output

Using MDX

Business Intelligence and MDX
Basic MDX Queries
Working with Levels
Working with Dimensions and Hierarchies
Working with Sets
Tuples and Cubes
Filtering a Query
Adding Summaries
Creating Calculated Measures and Members

MDX Reference

Basic Rules
Expression Types (MDX)
MDX Statements and Clauses
MDX Functions
Intrinsic Properties (MDX)
NOW Member for Time Levels
Quick Function Reference (MDX)

Power BI
BI Clients

Using Business Intelligence
DeepSee.js
Business Intelligence REST API

BI Tutorial

Business Intelligence Tutorial: Getting Started
Introduction to Cube Elements
Creating a Cube
Expanding the Cube Definition
Creating Subject Areas
Creating & Packaging Pivot Tables & Dashboards

Machine Learning

About...
Current Page: Using IntegratedML

Introduction to IntegratedML
IntegratedML Basics
Providers
ML Configurations
Model Maintenance

AutoML Reference

Introduction to AutoML
Highlighted Features of AutoML
Feature Engineering
Algorithms Used
Model Selection Process

Text Analytics (Natural Language Processing)

About Text Analytics
Conceptual Overview
NLP Implementation
Domain Architect
Domain Explorer
Indexing Results
REST Interface
Creating an NLP Environment Manually
Loading Text Data Programmatically
Performance Considerations when Loading Texts
NLP Queries
Semantic Attributes
Stemming
Skiplists
Filtering Sources
Text Categorization
Dominance and Proximity
Custom Metrics
Smart Matching: Creating a Dictionary
Smart Matching: Using a Dictionary
User Interfaces
InterSystems IRIS Natural Language Processing (NLP) Tools
iKnow Web Services
KPIs and Dashboards
Customizing NLP
Language Identification
Domain Parameters

Predictive Modeling Markup Language
Unstructured Information Management Architecture

Using UIMA Support

InterSystems Reports
InterSystems IRIS Adaptive Analytics

Class Reference

Opens in a new tab View this item as PDFOpens in a new tab Download all PDFsOpens in a new tab

InterSystems IRIS for Health 2025.1

AskMe (beta)

Responses may be inaccurate. Learn more about AskMe.

Report Issue with AskMe

If you're experiencing an issue with AskMe or want to provide feedback, email us at AskMeSupport@intersystems.com

Include relevant details, such as the response text or screenshots, to help us resolve the issue.

Using IntegratedML

Introduction to IntegratedML

Purpose
Introduction to Machine Learning

IntegratedML Basics

Creating Model Definitions
Training Models
Validating Models
Making Predictions
Walkthrough

Providers

AutoML
PMML

ML Configurations

Creating ML Configurations
Setting the ML Configuration
Maintaining ML Configurations

Model Maintenance

Viewing Models
Altering Models
Deleting Models

FeedbackOpens in a new tab

© 2025 InterSystems Corporation, Boston, MA. All rights reserved.

PrivacyOpens in a new tab & TermsOpens in a new tab GuaranteeOpens in a new tab AccessibilityOpens in a new tab

Cookies Settings Cookie List

Content date/time: 2025-07-02 19:11:39