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

2022 09 26

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:   

  • Progress.Collections.ICollection<T> interface  
  • Progress.Collections.IIterable<T> interface  
  • Progress.Collections.IIterator<T> interface  
  • Progress.Collections.IList<T> interface  
  • Progress.Collections.List<T> class  
  • Progress.Collections.ListIterator<T> class  

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: 

  • Simplified process. Collections eliminate the need to use temp-tables or write your data structures, reducing developer effort and code bloat; 
  • Familiar code. With Collections, you can simplify the code syntax, which will be immediately familiar to those who are used to writing object-oriented code; 
  • Easy-to-use with other technologies. Collections can also be used to serialise your data structures, allowing for easy interoperability between Progress OpenEdge and other technologies. Serialisation is an object’s conversion into a) a stream of bytes to be stored in memory; b) on a file to be recreated elsewhere when needed. If your application is split into multiple parts with different technologies, Collections can significantly reduce the effort required to set up data transfer between those other parts. 

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: 

  • Test group 1: Temp-tables can be more efficient when reading large text files and in certain cases in Windows, but overall, collection performs well; 
  • Test group 2: Temp-tables can have a performance advantage working with many records. Data finding performance is quite good with objects considering full scan; 
  • Test group 3: Collections should have a significant advantage if a temp-table is not passed by reference. 

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

Let’s work together

Want to discuss potential opportunities? Pick the most suitable way to contact us.

Book a call

+370 5 2 780 400
info@ba.lt

    privacy policy