Progress OpenEdge: why are Collections practical for your application development?

2022 09 26 · 4 min read

Progress OpenEdge already had a limited implementation of Collections with OpenEdge.Core.Collections package. At the beginning of 2022, Progress OpenEdge version 12.5 was released, which came along with a built-in list collection construct that any ABL application can use.  

In this blog, we explore what Collections are and go through the overview of the new release of Progress.Collections package, version 12.5, and its updated functionalities. 

What is a collection?   

If you would like to dive more into Progress OpenEdge, you can check out our blog post: What is Progress OpenEdge?   

When it comes to the description of a collection, Technopedia explains: “In programming, a collection is a class used to represent a set of similar data type items as a single unit. These unit classes are used for grouping and managing related objects.”    

A collection can be imagined as a temp-table, which stores objects of the same type instead of record data in fields. On top of that, a collection is an object itself, meaning it has associated methods that allow easy manipulation of the stored objects. For Progress OpenEdge version 12.5, the ‘List’ type collection has been implemented by adding six built-in classes and interfaces:   

Another feature in tandem with these new classes is the new syntax where type parameters are defined within angle brackets (<T> as seen above). This feature is used to describe generic types. 

Why are Collections useful in object-oriented applications? 

Features that will benefit you while creating a list in your code: 

Explore the code 

Below you will find a code snippet that shows the basics of working with ‘List’ type Collections. It includes creating the list, adding objects, and using the ‘Iterator’ class to iterate through stored objects.  

The code snippet below is a great starting point for you to try using Collections in Progress OpenEdge. Learn more about Collections and other features added with version 12.5 by reading release notes about the Collections in object-oriented ABL. 

BLOCK-LEVEL ON ERROR UNDO, THROW.  
VAR Progress.Collections.List<Order> orderList.  
VAR Progress.Collections.IIterator<Order> orderIterator.  
VAR order AnyOrder.  
// Create the list  
orderList = NEW Progress.Collections.List<Order>().  
FOR EACH Order NO-LOCK WHERE  
Order.SalesRep = "HXM":  
// Add elements to the list  
orderList:Add(NEW Order(Order.OrderNum)).  
END.  
// Retrieve the first element from the list  
AnyOrder = orderList:Get(1).  
// Replace the first element in the list  
orderList:Set(2, NEW Order(10000)).  
// Remove the second element from the list  
orderList:RemoveAt(3). 
// Print out some information  
MESSAGE 
"orderList info"  
orderList:Count  
orderList:Contains(AnyOrder)  
orderList:IndexOf(AnyOrder)  
orderList:Get(4):orderStatus  
.  
// Iterate over the entries in the list  
orderIterator = orderList:GetIterator().  
REPEAT WHILE orderIterator:MoveNext():  
orderIterator:Current:calcItems().  
orderIterator:Current:calcTotalPrice().  
END.  
DEFINE VARIABLE myFileOutStream AS Progress.IO.FileOutputStream.  
DEFINE VARIABLE mySerializer AS Progress.IO.JsonSerializer.  
mySerializer = NEW Progress.IO.JsonSerializer(FALSE).  
/* Serialize object */  
myFileOutStream = NEW Progress.IO.FileOutputStream("OrderList.json").  
mySerializer:Serialize(orderList, myFileOutStream).  
myFileOutStream:Close(). 
/* Also, possible to serialise to memptr */  
DEFINE VARIABLE memptrVar AS MEMPTR NO-UNDO.  
DEFINE VARIABLE myMemoryOutStream AS Progress.IO.MemoryOutputStream.  
myMemoryOutStream = NEW Progress.IO.MemoryOutputStream().  
mySerializer:Serialize(orderList, myMemoryOutStream).  
memptrVar = myMemoryOutStream:Data.   

Performance testing: temp-table vs collection 

We did limited performance testing of temp-table versus collection performance.  

Tests were performed on personal workstations on both Windows and Linux operating systems. Some tests involved reading large amounts of data from CSV files, adding them to temp-tables/lists, and performing operations with these data structures. The duration of each process was measured in milliseconds. Overall, the performance was found to be comparable. However, in some cases, there were noticeable disparities in performance between Linux and Windows operating systems. Unfortunately, with the limited scope of testing, we cannot say whether this is an optimisation problem, some bug, a quirk of the operating system, or the hardware.   

Worth mentioning as well is that there is a bug in version 12.5, which limits the maximum number of objects in the list collection (in our case, this was ~4105 objects). This has been fixed in version 12.5.1. Here is a table showing the conducted test: 

Insights after testing 

The performance testing showed three conclusions: 

 If you need help with Progress OpenEdge application development, the Baltic Amadeus team is ready to answer your questions.