Motivation

This project was thought of when I was thinking of how to let Python code deal naturally with the scalable storage and efficient retrieving mechanism given by IRIS globals, through Embedded Python.

My initial idea was to create a kind of Python dictionary implementation using globals, but soon I realized that I should deal with object abstraction first.

So, I started creating some Python classes that could wrap Python objects, storing and retrieving their data in globals, i.e., serializing and deserializing Python objects in IRIS globals.

How does it work?

You may have seen my series of articles on GlobalToJSON closing with Embedded Python.
And to me, Embedded means inside a Class and not PEX or other external variants.
The first variants showed that ePy is not an ultimate requirement. ISOS/COS may do it as well.
Here I try to position ePy inside IRIS.

I am creating "models" that contain rows in several class tables called Model, Path, Node.

So, model 19 includes 1 row in the Model table, 11 rows in the Path table, and 10 rows in the Node table. 

I'd like to write some utilities to "move" model 19 from one instance to another.

This package offers a utility to export an XLarge Global into a JSON object file and to show
or import it again. In a previous example, this all was processed in memory. But if this is a
large Global you may either experience <MAXSTRING> or an <STORE>  error
if the generated JSON structure exceeds available memory.
 

Academic refers to the structure created.

I have number of hosts on an Ensemble production that are not updating the %LastActivity property in the

^CacheTemp.EnsHostMonitor global. This in return create an issue with our dashboard software which is showing wrong results even as the host is processing messages without issues.

Hey Developers,

We are super excited to announce the winners of the InterSystems Globals contest!

The winners of the 19th programming contest are as follows:

Hi Community,

Here is a link to a short video demonstration of a globals project called Cubes.

The source code for the project can be found here

Cubes on GitHub

Hey Developers,

Let the voting week begin! It's time to cast your votes for the best applications in the Globals Contest!

🔥 You decide: VOTE HERE 🔥

 
How to vote? Details below.

Globals are the core of the InterSystems IRIS for data persistence. It is flexible, allowing store JSON documents, relational data, object oriented data, OLAP cubes and custom data models, like Mindmaps. To see how to store, delete and get mindmap data using globals, follow these steps:

1. Clone/git pull the repo into any local directory

$ git clone https://github.com/yurimarx/global-mindmap.git

2. Open a Docker terminal in this directory and run:

$ docker-compose build

3. Run the IRIS container:

$ docker-compose up -d

I have created a package that offers a utility to load a Global into JSON object and reverse     
to create a Global from this type of JSON object. Compact refers to the structure created.
Globals nodes are included with data for a fast data load.   
But also the related code is quite compact.

Hi contestants!

Here are the results of the bonus collections the applications of the Globals Contest accomplished.

Here are the projects that scored it:

Hi Community,

This article describes the small ZPM module global-archiver.
The goal is to move a part of a global from a database to another database.

Why this package?

A typical use case is read-only data sequentially added to your database that you can never delete.
For example:

• User log access to patient medical data.
• Medical documents versioning.

Hey Community,

Ready for the next contest? We are glad to invite you all to the 19th InterSystems online programming competition: 

🏆 InterSystems Globals Contest 🏆

Duration: March 21 - April 10, 2022

In prizes: $10,000

Hi Developers!

Here're the technology bonuses for the InterSystems IRIS Globals Contest 2022 that will give you extra points in the voting:

• Data-model implementation - 5
• Functional index implementation - 5
• Data Move usage - 3
• Embedded Python - 4
• Docker container usage - 2 
• ZPM Package deployment - 2
• Online Demo - 2
• First Article on Developer Community - 2
• Second Article On DC - 1
• Code Quality pass - 1
• Video on YouTube - 3

See the details below.

Hey Coommunity, 

Learn about InterSystems globals, the data model native to InterSystems IRIS® data platform that makes data storing efficient and provides the flexibility your data needs:

⏯ Flexible Data Modeling with InterSystems Globals

Hi Community,

We are pleased to invite all the developers to the upcoming InterSystems Globals Contest Kick-off Webinar! The topic of this webinar is dedicated to the Globals contest.

In this webinar, we’ll show you how to deal with Globals to implement different data models and sophisticated indexes. As always, our experts will answer the questions on how to develop, build, and deploy Globals solutions using InterSystems IRIS.

Date & Time: Monday, March 21 – 11:00 AM EDT

I have created a package that offers a utility to load a Global into JSON object and reverse     
to create a Global from this type of JSON object. Efficient refers to the structure created.
Only Globals nodes containing data are presented in the generated JSON object.

This example demonstrates the difference you may experience when you write to
Gllobals directly from Embedded Python compared to native ObjectScript.

To make this demo useful I start 2 background jobs that simply write sequentially
to a dedicated global. A common control method signals for a synchronous start.
Similar a common stop & view interrupts data feeding.

That's the principle process:

Hey InterSystems Community!
This is probably far-fetched - is there a way to get notified/get a piece of code triggered whenever the state of a global changes?

Now what could I possibly want with that? Quite simple! I would like to forward the content of a global (in this case the "FSLog" global written by the FHIR implementation) while adding timestamps to it - to create some sort of file-based logging for it.

Dear people,

I (really) spent hours on finding the maximum size a Global is allowed to be (for Windows, if that matters). All I seem to run into are database sizes (derived from a max number of blocks and block size), but I refuse to believe that is correct because too small to be realistic.  

In my article I described the work using iris.gref .
As the official documetation is rather slim on the subject it was necessary to dig into it.
Using the power of Python I was able to detect what I needed but was hidden.
I decided to share this with you. pydoc did the magic. 

Let's consider you would like to efficiently store your historical data in a similar structure than the one used for your current data, but without sharing the same physical storage (ie : not in the same global). What is the most efficient way to do it ?

Below a simple class of your current data : 

Hi developers!

As you probably noticed in IRIS 2021 the names of globals are random.

And if you create IRIS classes with DDL and want to be sure what global was created you probably would want to provide a name.

And indeed you can do it. 

Use WITH %CLASSPARAMETER DEFAULTGLOBAL='^GLobalName' in CREATE Table to make it work. Documentation. See the example below:

Hey developers!

Sometimes we need to insert or refer to the data of classes directly in globals.

And maybe a lot of you expect that data structure of global with records is:

^Sample.Person(Id)=$listbuild("",col1,col2,...,coln).

And this article is a heads up, that this is not always true, don't expect it as granted!

I have created a package to export a Global into JSON object file and to re-create it by reloading from this file   
embeddedPython refers to the new available technologies. It should be understood as a learning exercise of 
how to handle the language interfaces. Only Global nodes containing data are presented in the generated JSON file.
Differently from the previous example, this one is using embedded Python only, no ObjectScript. Therefore PURE

I have created a package to export a Global into JSON object file and to re-create it by reloading from this file   
embeddedPython refers to the new available technologies. It should be understood as a learning exercise of 
how to handle the language interfaces. Only Global nodes containing data are presented in the generated JSON file.

This package was triggered by the extra bonus points in the contest for writing the example
in embedded Python only.  Therefore PURE

I will give you some additional information on my first embedded Python package.
it is written as a mix of python and ObjectScript to take the best of both worlds.

I have created a package that offers a utility to load a Global into JSON object and reverse     
to create a Global from this type of JSON object. Academic refers to the structure created.
Each logical node of the Global is presented separately with all its descendants.
Even if they don't contain any stored data.

I started some development with the IRIS 2020.4 version and did not continue it for some months.

Now I just wanted to continue, but saw the license is not valid anymore.

Is there still a possibility to upgrade to 2021.2 community edition and to recover the globals from the old edition without having a valid license key?