发布新帖

検索

文章
· 四月 16, 2023 阅读大约需 4 分钟
Open Exchange

Tuples ahead

#API ##嵌入式 Python #ObjectScript #Python #InterSystems IRIS #InterSystems IRIS for Health

Overview

Cross-Skilling from IRIS objectScript to Python it becomes clear there are some fascinating differences in syntax.

One of these areas was how Python returns Tuples from a method with automatic unpacking.

Effectively this presents as a method that returns multiple values. What an awesome invention :)

out1, out2 = some_function(in1, in2)

ObjectScript has an alternative approach with ByRef and Output parameters.

Do ##class(some_class).SomeMethod(.inAndOut1, in2, .out2)

Where:

  • inAndOut1 is ByRef
  • out2 is Output

The leading dot (".") in front of the variable name passes ByRef and for Output.

The purpose of this article is to describe how the community PyHelper utility has been enhanced to give a pythonic way to take advantage of ByRef and Output parameters. Gives access to %objlasterror and has an approach for Python None type handling.
 

    Example ByRef

    Normal invocation for embedded python would be:

    oHL7=iris.cls("EnsLib.HL7.Message")._OpenId('er12345')

    When this method fails to open, variable "oHL7" is an empty string.
    In the signature of this method there is a status parameter that is available to object script that gives an explanation of the exact problem.
    For example:

    • The record may not exist
    • The record couldn't be opened in default exclusive concurrency mode ("1"), within timeout
    ClassMethod %OpenId(id As %String = "", concurrency As %Integer = -1, ByRef sc As %Status = {$$$OK}) As %ObjectHandle

    The TupleOut method can assist returning the value of argument sc, back to a python context.
     

    > oHL7,tsc=iris.cls("alwo.PyHelper").TupleOut("EnsLib.HL7.Message","%OpenId",['sc'],1,'er145999', 0)
> oHL7
''
> iris.cls("%SYSTEM.Status").DisplayError(tsc)
ERROR #5809: Object to Load not found, class 'EnsLib.HL7.Message', ID 'er145999'1
```

    The list ['sc'] contains a single item in this case. It can return multiple ByRef values, and in the order specified. Which is useful to automatically unpack to the intended python variables.

    Example Output parameter handling

    Python code:

    > oHL7=iris.cls("EnsLib.HL7.Message")._OpenId('145')
> oHL7.GetValueAt('<%MSH:9.1')
''

    The returned string is empty but is this because the element is actually empty OR because something went wrong.
    In object script there is also an output status parameter (pStatus) that can be accessed to determine this condition.

    Object script code:

    > write oHL7.GetValueAt("<%MSH:9.1",,.pStatus)
''
> Do $System.Status.DisplayError(pStatus)
ERROR <Ens>ErrGeneral: No segment found at path '<%MSH'

    With TupleOut the equivalent functionality can be attained by returning and unpacking both the method return value AND the status output parameter.

    Python code:

    > hl7=iris.cls("EnsLib.HL7.Message")._OpenId(145,0)
> val, status = iris.cls("alwo.PyHelper").TupleOut(hl7,"GetValueAt",['pStatus'],1,"<&$BadMSH:9.1")
> val==''
True
> iris.cls("%SYSTEM.Status").IsError(status)
1
> iris.cls("%SYSTEM.Status").DisplayError(status)
ERROR <Ens>ErrGeneral: No segment found at path '<&$BadMSH'1


    Special variable %objlasterror

    In objectscript there is access to percent variables across method scope.
    There are scenarios where detecting or accessing special variable %objlasterror is useful after calling a CORE or third party API
    The TupleOut method allows access to %objlasterror, as though it has been defined as an Output parameter, when invoking methods from Python

    > del _objlasterror

> out,_objlasterror=iris.cls("alwo.PyHelper").TupleOut("EnsLib.HL7.Message","%OpenId",['%objlasterror'],1,'er145999', 0) 

> iris.cls("%SYSTEM.Status").DisplayError(_objlasterror)
ERROR #5809: Object to Load not found, class 'EnsLib.HL7.Message', ID 'er145999'1

    When None is not a String

    TupleOut handles python None references as objectscript undefined. This allows parameters to default and methods behave consistently.
    This is significant for example with %Persistent::%OnNew where the %OnNew method is not triggered when None is supplied for initvalue, but would be triggered if an empty string was supplied.

    In objectscript the implementation might say: 

    do oHL7.myMethod("val1",,,"val2")

    Note the lack of variables between commas.

    TupleOut facilitates the same behavior with:

    Python:

    iris.cls("alwo.PyHelper").TupleOut(oHL7,"myMethod",[],0,"val1",None,None,"val2")

    Another way to consider this, is being able to have one line implementation of invocation code, that behaves flexibly depending on pre-setup of variables:

    Object Script:

    set arg1="val1"
kill arg2
kill arg3
set arg4="val2"
do oHL7.myMethod(.arg1, .arg2, .arg3, .arg4)

    TupleOut facilitates the same behavior with:

    Python:

    arg1="val1"
arg2=None
arg3=None
arg4="val2"
iris.cls("alwo.PyHelper").TupleOut(oHL7,"myMethod",[],0,arg1,arg2,arg3,arg4)

    List and Dictionaries

    When handling parameters for input, ByRef and Output, TupleOut utilizes PyHelper automatic mapping between:
    IRIS Lists and Python Lists
    IRIS Arrays and Python Arrays
    Where it takes care to always use strings to represent dictionary keys when moving from IRIS Arrays to Python Dict types.

    Conclusion

    Hope this article helps inspire new ideas and discussion for embedded Python ideas and suggestions.

    Hope also it gives encouragement to explore the flexibility for how IRIS can easily bend to meet new challenges.

    讨论 (0)1
    登录或注册以继续
    InterSystems 官方
    · 四月 13, 2023

    InterSystems announces availability of InterSystems IRIS, IRIS for Health, & HealthShare Health Connect 2022.1.3

    #版本 #Health Connect #HealthShare #InterSystems IRIS #InterSystems IRIS for Health #InterSystems 官方

    InterSystems is pleased to announce that the extended maintenance release of InterSystems IRIS, InterSystems IRIS for Health, and HealthShare Health Connect 2022.1.3 is now available. This release provides a few selected features and bug fixes for the previous 2022.1.x releases.

    You can find additional information about what has changed on these pages:

    Please share your feedback through the Developer Community so we can build a better product together.

    How to get the software

    The software is available as both classic installation packages and container images.  For the complete list of available installers and container images, please refer to the Supported Platforms webpage.

    Full installation packages for both InterSystems IRIS and InterSystems IRIS for Health are available from this WRC's InterSystems IRIS Data Platform Full Kits. page. HealthShare Health Connect kits are available from WRC's HealthShare Full Kits page.

    Container images  are available from the InterSystems Container Registry.

    There are no Community Edition kits or containers available for this release.

    The number of all kits & containers in this release is 2022.1.3.668.0.

    讨论 (0)1
    登录或注册以继续
    文章
    · 四月 13, 2023 阅读大约需 8 分钟

    What you always wanted to know about InterSystems IRIS but were afraid to ask :)

    #InterSystems IRIS

    What is InterSystems IRIS?

    InterSystems IRIS is a high-performance data platform designed for developing and deploying mission-critical applications. It is a unified data platform that combines transaction processing, analytics, and machine learning in a single product.

    InterSystems IRIS provides a comprehensive set of data management and development tools that enable developers to build, integrate, and deploy applications with ease. It supports a wide range of data models, including relational, object-oriented, hierarchical, and document-based models, and provides a powerful set of APIs for accessing data.

    InterSystems IRIS is used in a variety of industries, including healthcare, finance, logistics, and more, to power critical applications such as electronic health records, financial trading systems, and supply chain management platforms. It is known for its scalability, reliability, and ease of use, and is used by some of the world's largest organizations to manage their most important data-driven applications.

    What type of database is InterSystems IRIS?

    InterSystems IRIS is a multi-model database, which means that it supports multiple data models including relational, object-oriented, and document-based models. It is designed to be highly flexible and adaptable, allowing developers to choose the data model that best fits their application's requirements.

    InterSystems IRIS supports standard SQL for relational data management, and it also provides advanced indexing capabilities and query optimization to improve performance. In addition, it supports NoSQL document-oriented data storage, allowing developers to work with unstructured and semi-structured data. The object-oriented data model in InterSystems IRIS allows developers to work with complex data structures and build object-oriented applications.

    The multi-model architecture of InterSystems IRIS provides developers with the flexibility to work with different types of data in a single database, simplifying application development and management. This makes it a popular choice for building high-performance, data-driven applications in a variety of industries.

    What is the InterSystems IRIS database?

    InterSystems IRIS is a high-performance database management system (DBMS) that is designed to handle a wide variety of data management tasks. It is developed by InterSystems Corporation, a software company that specializes in providing data management, interoperability, and analytics solutions to businesses and organizations around the world.

    InterSystems IRIS is a powerful and flexible database platform that can handle both structured and unstructured data, and can be used for a variety of applications, including transaction processing, analytics, and machine learning. It provides a rich set of features and tools for managing data, including support for SQL, object-oriented data modeling, multi-dimensional data analysis, and integrated development and deployment tools.

    One of the key features of InterSystems IRIS is its ability to handle large amounts of data with high performance and scalability. It uses advanced caching and indexing techniques to optimize data access, and can be configured to work with a wide range of hardware configurations and operating systems.

    InterSystems IRIS also includes advanced security features, such as role-based access control, encryption, and auditing, to ensure the confidentiality, integrity, and availability of data.

    Overall, InterSystems IRIS is a powerful and flexible database platform that can help businesses and organizations manage their data more effectively and efficiently.

    What is InterSystems IRIS HealthShare?

    InterSystems IRIS HealthShare is a healthcare-specific platform that builds on top of InterSystems IRIS database and integration engine to provide a comprehensive solution for healthcare organizations. It is designed to enable healthcare organizations to securely and efficiently share patient data across different systems and applications, while also providing advanced analytics and insights to improve patient care.

    InterSystems IRIS HealthShare includes a wide range of features and tools, including:

    1. Health Information Exchange (HIE) capabilities that enable healthcare organizations to securely exchange patient data across different systems and providers.
    2. Master Patient Index (MPI) functionality that ensures accurate patient identification and record matching, even in the face of incomplete or inconsistent data.
    3. Clinical Viewer and Patient Portal that enable patients and clinicians to view and interact with patient data in a secure and intuitive way.
    4. Analytics and Business Intelligence tools that enable healthcare organizations to analyze patient data and identify patterns and trends that can improve patient outcomes and drive operational efficiencies.
    5. Interoperability capabilities that enable healthcare organizations to connect to and exchange data with a wide range of external systems and devices.

    Overall, InterSystems IRIS HealthShare is a powerful and flexible platform that can help healthcare organizations improve the quality of patient care while also reducing costs and improving operational efficiency.

    How is InterSystems IRIS data stored?

    InterSystems IRIS stores data using a hierarchical, multi-dimensional data model. Each element of it is called a Global. A Global is a persistent, hierarchical data structure that can be thought of as a collection of nodes that are organized into a tree-like structure. Each node in the tree is identified by a unique path, which is formed by concatenating a series of labels, separated by caret (^) characters.

    A Global can store a wide variety of data types, including strings, numbers, and binary data, and can be accessed using a variety of programming languages and APIs, including SQL, object-oriented programming, and Web services.

    InterSystems IRIS also provides a flexible and scalable indexing system that enables efficient retrieval of data from Globals. The indexing system allows developers to define custom indexes on specific attributes of the data, which can be used to quickly retrieve subsets of data that meet specific criteria.

    In addition to Globals, InterSystems IRIS also supports other data storage mechanisms, including relational tables, multidimensional arrays, and JSON documents. Relational tables are based on the SQL standard and provide a structured, tabular way to store data. Multidimensional arrays are used to store data that is organized into matrices or cubes, while JSON documents are used to store unstructured or semi-structured data.

    Overall, InterSystems IRIS provides a flexible and powerful data storage system that can handle a wide variety of data types and data models, making it well-suited for a wide range of applications and use cases.

    Is InterSystems IRIS a programming language?

    InterSystems IRIS is not a programming language itself, but it provides support for a variety of programming languages and APIs. Some of the programming languages that are supported by InterSystems IRIS include:

    1. ObjectScript: InterSystems' proprietary programming language, which is used for developing applications that run on the InterSystems IRIS platform.
    2. SQL: InterSystems IRIS provides full support for the SQL programming language, which can be used to interact with relational data stored in InterSystems IRIS.
    3. Java and .NET: InterSystems IRIS provides support for both the Java and .NET programming languages, which can be used to develop applications that interact with InterSystems IRIS.
    4. REST and SOAP APIs: InterSystems IRIS provides support for both RESTful and SOAP-based APIs, which can be used to develop Web services that interact with InterSystems IRIS.
    5. Node.js: InterSystems IRIS also provides support for Node.js, a popular JavaScript runtime environment, which can be used to develop server-side applications that interact with InterSystems IRIS.
    6. Python: InteSystems provides support for Python programming language, which can be used as one of the languages to develop applications that run on the InterSystems IRIS platform and as an API.

    Overall, while InterSystems IRIS is not a programming language in and of itself, it provides a wide range of tools and APIs that enable developers to build and deploy applications using a variety of programming languages and frameworks.

    Which model is best for InterSystems IRIS data?

    InterSystems IRIS supports a variety of data models, including hierarchical, relational, multidimensional, and document-based (JSON). The best model for your specific use case will depend on a variety of factors, including the nature of the data, the types of queries and analysis you need to perform, and the overall architecture of your application. Here are some general guidelines for choosing the best data model for your InterSystems IRIS implementation:

    1. Hierarchical Model: If your data has a hierarchical structure, such as patient records in a healthcare application or parts and subassemblies in a manufacturing system, a hierarchical model may be the best choice. Hierarchical models are optimized for fast traversal of tree-like structures and can provide excellent performance for certain types of queries and updates.
    2. Relational Model: If your data is highly structured and requires complex queries or joins, a relational model may be the best choice. Relational databases are well-suited for handling large amounts of structured data and provide powerful querying and reporting capabilities.
    3. Multidimensional Model: If your data is organized into matrices or cubes, such as financial data or scientific data, a multidimensional model may be the best choice. Multidimensional databases are optimized for fast querying and analysis of complex data structures.
    4. Document-Based Model: If your data is unstructured or semi-structured, such as social media posts or log files, a document-based model may be the best choice. Document databases are optimized for storing and querying unstructured data and can provide excellent performance for certain types of queries.

    What is InterSystems IRIS famous for?

    InterSystems IRIS is famous for several reasons, including:

    1. High Performance: InterSystems IRIS is known for its high performance and scalability, making it a popular choice for data-intensive applications that require fast and reliable data access.
    2. Integration Capabilities: InterSystems IRIS provides powerful integration capabilities, allowing it to connect to and exchange data with a wide range of external systems and applications. This makes it an ideal choice for organizations that need to integrate data from multiple sources or build complex data-driven applications.
    3. Flexibility: InterSystems IRIS supports a wide range of data models, programming languages, and APIs, giving developers the flexibility to choose the tools and approaches that work best for their specific needs.
    4. Healthcare Focus: InterSystems IRIS is widely used in the healthcare industry, where it is known for its powerful clinical data management capabilities and support for industry-standard data exchange formats.
    5. Developer Community: InterSystems has a large and active developer community, which provides support, resources, and best practices for building and deploying applications using InterSystems IRIS.

    Overall, InterSystems IRIS has earned a reputation as a powerful and flexible data management platform that can support a wide range of use cases and industries, making it a popular choice for organizations around the world.

    讨论 (0)1
    登录或注册以继续
    文章
    · 四月 12, 2023 阅读大约需 8 分钟

    Determining Global and Table Sizes in InterSystems IRIS

    #数据库 #Globals #监视 #InterSystems IRIS

    Spoilers: Daily Integrity Checks are not only a best practice, but they also provide a snapshot of global sizes and density. 

    Update 2024-04-16:      As of IRIS 2024.1, Many of the below utilities now offer a mode to estimate the size with <2% error on average with orders of magnitude improvements in performance and IO requirements. I continue to urge regular Integrity Checks, however there are situations where more urgent answers are needed.

    • EstimatedSize^%GSIZE- Runs %GSIZE in estimation mode.   
    • ##class(%Library.GlobalEdit).GetGlobalSize(directory, globalname, .allocated, .used. 2)  - Estimate the global size programmatically returning the allocated space and used space. Note the final parameter must be a 2.   
    • CALL %SYS.GlobalQuery_Size('directory', '','*',,,2) - Retrieve estimated global sizes by SQL

    Tracking the size of the data is one of the most important activities for understanding system health, tracking user activity, and for capacity planning ahead of your procurement process. InterSystems products store data in a tree-structure called globals. This article discusses how to determine global sizes – and therefore the size of your data. The focus is on balancing impact versus precision. 

    SQL tables are simply a projection of underlying globals. Looking at table size currently means needing to look at the corresponding global sizes. A more efficient sampling-based mechanism is currently being developed. Understanding the relationship between tables and globals may require some additional steps, discussed below.

    Data

    The specific data that needs to be collected varies depending on the specific question you're trying to answer. There is a fundamental difference between the space "allocated" for a global and the space "used" by a global which is worth considering. In general, the allocated space is usually sufficient as it corresponds to the space used on disk. However, there are situations where the used space and packing data are essential -- e.g. when determining if a global is being stored efficiently following a large purge of data. 

    • Allocated Space - These are units of 8KB blocks. Generally, only one global can use one block. Therefore, even the smallest global occupies at least 8KB. This is also functionally the size on disk of the global. Determining allocated space only requires examining bottom-pointer blocks (and data-blocks which contain big-strings). Except in rare or contrived scenarios, there are typically multiple orders of magnitude fewer pointer blocks than data blocks.  This metric is usually sufficient to understand growth trends if collected on a regular basis.
    • Used Space – “Used” is the sum of the data stored within the global and the necessary overhead. Globals often allocate more space on disk than is actually “used” as a function of usage patterns and our block structure.
      • Packing: Calculating the actual space used will also provide information about the global “packing” – how densely the data is stored. It can sometimes be necessary or desirable to store the globals more efficiently -- especially if they are not frequently updated. For systems with random updates, inserts, or deletes, a packing of 70% is generally considered optimal for performance. This value fluctuates based on activity. Spareness most often correlates with deletions. 
      • IO Cost: Unfortunately, with great precision comes great IO requirements. Iterating 8KB block by 8KB block through a large database will not only take a long time, but it may also negatively impact performance on systems that are already close to their provisioned limits. This is much more expensive than determining if a block is allocated. This operation will take on the order of (# of parallel processes) / (read latency) * (database size – free space) to return an answer. 

    InterSystems provides several tools for determining the size of globals within a particular database. Generally, both the global name and the full path of the underlying database directory need to be known in order to determine the size. For more complex deployments, math is required to determine the total size of a global spread across multiple databases via subscript level mapping.

    Determining Global Names:

    • Use the Extent Manager to list the globals associated with a table:
      • SQL: Call %ExtentMgr.GlobalsUsed('Package.Class.cls')
    • Review the storage definition within the Management Portal, within VS Code (or Studio), or by querying %Dictionary.StorageDefinition.
      • SQL: SELECT DataLocation FROM %Dictionary.StorageDefinition WHERE parent = 'Package.ClassName'
      • ObjectScript: write ##class(%Dictionary.ClassDefinition).%OpenId("Package.ClassName").Storages.GetAt(1).DataLocation
    • Hashed Global Names are common when the tables are defined using DDLs, i.e. CREATE TABLE. This behavior can be modified by specifying USEEXTENTSET and DEFAULTGLOBAL. Using hashed global names and storing only one index per global have shown performance benefits. I use the following query to list the non-obvious globals in a namespace
      • SQL for All Classes: 
        SELECT Parent, DataLocation, IndexLocation, StreamLocation 
FROM %Dictionary.StorageDefinition
WHERE Parent->System = 0 AND DataLocation IS NOT NULL
      • SQL for Specific Classes: 
        CALL %ExtentMgr.GlobalsUsed('Package.Class.cls')

    Determining Database Path:

    • For the simplest deployments where a namespace does not have additional global mappings for application data, it is often possible to substitute "." for the directory. That syntactic sugar will tell the API to look at the current directory for the current namespace.
    • For SQL oriented deployments, CREATE DATABASE follows our best practices and creates TWO databases -- one for code and one for data. It’s best to verify the default globals database for the given Namespace in the Management Portal or in the CPF.
    • It is possible to programmatically determine the destination directory for a particular global (or subscript) in the current namespace:
      • ObjectScript: 
        set global = "globalNameHere" 
set directory = $E(##class(%SYS.Namespace).GetGlobalDest($NAMESPACE, global),2,*)
    • For more complex deployments with many mappings, it may be necessary to iterate through Config.MapGlobals in the %SYS Namespace and sum the global sizes:
      • SQL: SELECT Namespace, Database, Name FROM Config.MapGlobals

    Determining Global Sizes:

    Once the name of the global and the destination database path are determined, it is possible to collect information on the global size. Here are a few options:  

    • Integrity Check – Nightly Integrity Checks are a good practice. An even better practice is to perform them against a restored backup to also verify the backup and restore process while offloading the IO to another system. This process verifies the physical integrity of the database blocks by reading each allocated block. It also tabulates both the allocated space of all the globals AND tracks the average packing of the blocks along the way.
      • See Ray’s great post on Integrity Check performance.
      • In IRIS 2022.1+, Integrity Checks can now even multi-process a single global.
      • Example Integrity Check Output:  
        Global: Ens.MessageHeaderD                            0 errors found   
Top Pointer Level:    # of blocks=1      8kb (2% full)   
Pointer Level:        # of blocks=25      200kb (19% full)   
Bottom Pointer Level: # of blocks=3,257      25MB (79% full)   
Data Level:           # of blocks=2,630,922      20,554MB (88% full)   
Total:                # of blocks=2,634,205      20,579MB (88% full)   
Elapsed Time = 238.4 seconds, Completed 01/17/2023 23:41:12  
    • %Library.GlobalEdit.GetGlobalSize – The following APIs can be used to quickly determine the allocated size of a single global. This may still take some time for multi-TB globals.
      • ObjectScript: w ##class(%Library.GlobalEdit).GetGlobalSize(directory, globalName, .allocated, .used, 1)
      • Embedded Python: 
        import iris 
allocated = iris.ref("")
used =iris.ref("")
fast=1
directory = "/path/to/database"
global = "globalName"
iris.cls('%Library.GlobalEdit').GetGlobalSize(directory, global, allocated, used, fast)
allocated.value
used.value
    • %Library.GlobalEdit.GetGlobalSizeBySubscript – This is helpful for determining the size of subscript or subscript range. E.g. Determine the size of one index. It will include all descendants within the specified range. Warning: as of IRIS 2023.1 there is not a “fast” flag to only return the allocated size. It will read all of the data blocks within the range.
      • ObjectScript: ##class(%Library.GlobalEdit).GetGlobalSizeBySubscript(directory, startingNode, EndingNode, .size)
    • %SYS.GlobalQuery.Size – This API is helpful for surveying multiple globals within a database, with or without filters. A SQL Stored Procedure available for customers that primarily interact with IRIS via SQL.
      • SQL: CALL %SYS.GlobalQuery_Size('database directory here', '','*',,,1)
    • ^%GSIZE – Executing this legacy utility and choosing to “show details” will read each data block to determine the size of the data. Without filtering the list of globals, it may read through almost the entire database block by block with a single thread.
      • Running ^%GSIZE with details is the slowest option for determining global sizes. It much slower than our heavily optimized Integrity Checks! 
      • There is an additional entry point that will return the allocated size for a particular global – including when scoped to a subscript. Unfortunately, it does not work on subscript ranges.
      • ObjectScript: write $$AllocatedSize^%GSIZE("global(""subscript"")")
    • Database Size – The easiest case for determining global size is when there is only a single global within a single database. Simply subtract the total free space within the database from the total size of the database. The database size is available from the OS or via SYS.Database. I often use a variation of this approach to determine the size of a disproportionately large global by subtracting the sum of all the other globals in the database.
      • ObjectScript: ##class(%SYS.DatabaseQuery).GetDatabaseFreeSpace(directory, .FreeSpace)
      • SQL: call %SYS.DatabaseQuery_FreeSpace()
      • Embedded Python:
      • import iris
freeSpace = iris.ref("")
directory = "/path/to/database"
iris.cls('%SYS.DatabaseQuery').GetDatabaseFreeSpace(directory, freeSpace)
freeSpace.value  
    • Process Private Globals - PPGs are special process-scoped globals stored within IRISTEMP. They are often not enumerated by the other tools. When IRISTEMP is expanding rapidly or reporting low freespace, PPGs are frequently the explanation. Consider examining the per process usage of PPGs via %SYS.ProcessQuery. 
      • SQL: SELECT PID, PrivateGlobalBlockCount FROM %SYS.ProcessQuery ORDER BY PrivateGlobalBlockCount DESC

    Questions for the readers:

    1. How often do you track your global sizes?
    2. What do you do with global size information?  
    3. For SQL focused users, do you track the size of individual indices?
    5 Comments
    讨论 (5)2
    登录或注册以继续
    InterSystems 官方
    · 四月 10, 2023

    April 10, 2023 - Alert: ECP Client Instability

    #ECP #Health Connect #HealthShare #InterSystems IRIS #InterSystems IRIS for Health #InterSystems 官方

    InterSystems has corrected a defect that can result in Enterprise Cache Protocol (ECP) client instability under rare conditions.

    The defect exists in the following products and any InterSystems offerings based on them.

    Impacted versions are 2022.1.x, 2022.2, and 2022.3:

    InterSystems IRIS®

    InterSystems IRIS for Health™

    HealthShare® Health Connect

    Impacted version is 2022.2 (only for customers deploying ECP):

    InterSystems HealthShare®

    The issue can only occur on ECP client systems. When this issue is triggered, processes may experience a <SYSTEM> or <DATABASE> error. Following the error, the ECP client experiences instability; in some cases, the instance may hang. There is no impact to data and the ECP data server is unaffected.

    To clear the instability, you must restart the ECP client instance.

    If you have an impacted instance of IRIS, IRIS for Health, or Health Connect, the remediation is to upgrade to either version 2023.1 or 2022.1.3, both of which will be released shortly.

    If you have an impacted instance of HealthShare, a separate set of alert documentation with remediation recommendations will be released shortly.

    The correction for the defect is identified as TR1162 and will be included in all future versions of InterSystems IRIS®, InterSystems IRIS for Health™, and HealthShare® Health Connect as well as any InterSystems products based on them.

    The correction is also available via Ad hoc distribution.

    If you have any questions regarding this alert, please contact the Worldwide Response Center.

    讨论 (0)1
    登录或注册以继续