ProcessMIX Guide
  • Platform Overview
    • Introduction
    • Platform Purpose
    • Main Concepts
      • Organization Structure
      • Visual Language
      • Project Development Environment (IDE)
      • Deployment and Integration
      • Administration and Troubleshooting
    • First Steps
    • Change Log
      • 5.0.0
      • 5.0.5
      • 5.0.5.1
      • 5.0.5.2
      • 5.0.5.3
      • 5.0.5.4
  • Language Reference Guide
    • Overview
    • Data Structures and Types
      • Core Types (pdk.core)
      • Dictionary (pdk.asset.dictionary)
      • Scorecard (pdk.asset.scorecard)
      • Blockchain (pdk.blockchain)
      • Exceptions (pdk.ex)
      • Input/Output (pdk.io)
      • JSON Web Token (pdk.jwt)
      • Networking (pdk.net)
      • HTTP (pdk.net.http)
      • SOAP/Web Services (pdk.net.soap)
      • XML/DOM (pdk.net.xml)
      • S3 (pdk.s3)
      • SQL (pdk.sql)
      • Postgres (pdk.db.postgre)
      • Util (pdk.util)
      • Default Data Structure Field Values
    • Flows
      • Variables
        • Local Flow Variables
        • Node Variables
      • Flow Node Types
        • Core Nodes
          • In
          • Out
          • Assign
          • If
          • Switch
          • Iterator
          • Function Call
          • Subflow
          • Raise Exception
          • Exception Handler
          • Validator
        • Connector Nodes
          • Database Begin Transaction
          • Database Commit Transaction
          • Database Rollback Transaction
          • Database Query Executor
          • EVM Blockchain Functions
          • EVM Blockchain Smart Contract Functions
          • REST Service Executor
          • SOAP Service Executor
          • S3 Connector
          • SMB Connector
      • Expressions
      • Built-In Functions
        • Expression functions
          • pdk.util.Any
          • pdk.util.Array
          • pdk.util.Blockchain
          • pdk.util.Cast
          • pdk.util.Codec
          • pdk.util.Crypto
          • pdk.util.Date
          • pdk.util.File
          • pdk.util.Json
          • pdk.util.JWT
          • pdk.util.Map
          • pdk.util.Math
          • pdk.util.String
          • pdk.util.Util
        • Node functions
          • pdk.flow.Any
          • pdk.flow.Array
          • pdk.flow.File
          • pdk.flow.JsonArray
          • pdk.flow.JsonObject
          • pdk.flow.HttpRequest
          • pdk.flow.HttpResponse
          • pdk.flow.Logger
          • pdk.flow.Map
          • pdk.flow.Xml
            • pdk.flow.xml.XmlAttr
            • pdk.flow.xml.XmlElement
            • pdk.flow.xml.XmlNode
            • pdk.flow.xml.XmlDocument
            • pdk.flow.xml.XmlDocumentType
            • pdk.flow.xml.XmlDOMConfiguration
            • pdk.flow.xml.XmlDOMImplementation
            • pdk.flow.xml.XmlProcessingInstruction
            • pdk.flow.xml.XmlTypeInfo
            • pdk.flow.xml.XmlCharacterData
            • pdk.flow.xml.XmlText
            • pdk.flow.xml.XmlNamedNodeMap
          • pdk.node.BlockchainEth
          • pdk.node.S3
          • pdk.node.Smb
      • Exceptions
        • Checked Exceptions
        • Runtime Exceptions
    • Assets
      • Dictionary
      • Decision Table
      • Scorecard
      • PMML
    • Connectors
      • DB Connector
        • Prepared Query
        • Dynamic Query
        • Query input parameters
        • Stored Procedure
      • REST Connector
      • SOAP Connector
      • S3 Connector
      • SMB Connector
      • EVM Blockchain Connector
    • Global Variables
    • Appendices
      • Overview of Database Transactions
      • Reserved Words
  • Project Development Environment (IDE)
    • Project Explorer Panel
    • Flow Builder
    • Flow Node Editor
    • Data Structure Builder
    • Connector Builders
      • REST Connector Builder
      • SOAP Connector Builder
      • DB (Database) Connector Builder
      • EVM Blockchain Connectors Builder
      • S3 Connector Builder
    • Asset Builders
      • Dictionary Builder
      • Decision Table Builder
      • Scorecard Builder
      • PMML Asset Builder
    • Global Variables Panel
    • Expression Editor
    • Project Deployment and Execution
    • Cron Expression Generator
    • Test Helper
    • Debugging the Project
    • DB transactions
    • Team Collaboration Tools
      • Version Control
      • Conflict Resolver
    • Selectors
    • Error Panel
    • Local History
  • Home and Administration Guide
    • Organization and Subscription
    • Organization Team
    • Repositories and Projects
    • Environments
    • Deployments
    • Database Provisioning
    • Roles and Permissions
  • Logs and Troubleshooting
    • Request/Call Logs
    • Deployment Logs
    • Application Logs
  • Appendix: Example Project
    • Risk Mitigation Solution
Powered by GitBook
On this page
  • Data Structure Inheritance
  • Data Structure Parameterization
  • Standard (Built-In) Data Structures
  1. Language Reference Guide

Data Structures and Types

Data structure in ProcessMIX is a named definition of a set of value-holding properties, also known as attributes or fields.

It provides a systematic way to model and process structured information, from simple to very complex, automating operations such as creation, deletion, searching and reasoning over data.

The name of a data structure definition record must be unique within a project's folder where it is defined. Individual properties listed in it also have names that must be unique within that structure.

The data values that such properties represent can be of one of simple data types:

  • String

  • Numeric (Integer for storing whole numbers, Float for real, i.e. fractional numbers, or Byte for short signed integers)

  • Boolean (true/false)

  • Date (date/time)

They can also be of more complex types:

  • Array (a collection of values)

  • Map (a colleciton of key-value lookup pairs)

  • Another user-defined or built-in data structure.

When used together, this mechanism allows describing tree-like data constructs of any level of complexity.

For example, the following data structure describes some information about a person:

Person extends UserObject
    name: String
    birthDate: Date
    weight: Integer
    address: Address
    children: Array<Person>

Data structures themselves do not hold the actual data - they only describe what it will look like when a program is executed at runtime. Variable is another concept in ProcessMIX, addressing that part. Variables reserve space for and give unique names to specific instances of data structures (or just simple fields) that are filled with real data when the program is run.

For example, a "Person" data structure describes what type of information can be collected about any person, but an "applicant: a Person" variable in a flow can be used to reserve space and refer to a specific person who's details will be evaluated in a specific loan application request. And another variable with a different name but same "Person" type can be used to hold information about another person.

Data Structure Inheritance

Inheritance is a mechanism that allows some data structure (called derived structure) to extend another, more general structure (called a base structure, or superstructure), so that it can inherit shared properties from the base and define some more properties of its own - thus making it more specific.

Inheritance establishes a relationship where multiple derived structures can be defined as more specialized versions of the same base structure. This helps to reduce the amount of development work, allowing base properties and business logic to be described only once but still apply to many specific scenarios that have some information in common between them.

Here is an example of inheritance:

1. Person is a structure with properties: FirstName, LastName, Email
2. Employee is a Person with a property: Salary

A variable of type Employee will now have 4 properties: FirstName, LastName, Email, and Salary.

Data Structure Parameterization

Parametrization is another concept that is used to define a data structure and its properties once, but make it capable of handling different types information in different places in a program where it is applied.

For example, an Array in ProcessMIX can be used to store collections with multiple data records of the same type, allowing to process them using operations such as count (array size), iteration (go through each element and apply some logic to it), add, delete or move an element.

But the actual types of data records will be different in every place where an array-typed property is declared, and it is not know upfront what they will be until business logic is defined. So the Array data structure type must take a parameter, through which a user can specify the type of a data elements that this array will hold. The presence of such parameters is why these structures are called "parameterized"

Example of parametrization:

Person extends pdk.core.UserObject
    children: Array<Person>
    hobbies: Array<String>

As can be seen, the same "Array" type is used in two different properties, but it is parameterized with two different types of elements that they will hold - so the program will be able to count both the number of children and the number of hobbies of that person using the same logic, yet be able to apply very different logic when reasoning about individual elements of these two arrays.

Standard (Built-In) Data Structures

Users of ProcessMIX are expected to define their own data structures whenever necessary. However, many such structures come predefined as a part of the plaftorm itself in the standard PDK ("ProcessMIX Development Kit") library.

Some of them are used as base types from which all others are derived:

Others represent standard data types (such as simple types, arrays and maps), and many more describe sets of information/parameters utilized by the platform to perform various useful operations when called for by user-defined flows. They are grouped in packages:

PreviousOverviewNextCore Types (pdk.core)

Last updated 6 months ago

Here, "Person" is the name of the data structure, "UserObject" is a base structure that it extends or from, and the rest are properties of various types to hold individual bits of information about that person. The Array<Person> is an example of a data structure.

The section explains how to use the project IDE to define your own structures.

is a superstructure for all structures

is a superstructure for all not-system (created by users) structures

is a superstructure for all

- contains core structures such as String, Integer, Date, Array and others

- contains structures to operate with Dictionaries

- contains structures to operate with Structures

- contains structures to support blockchains integrations

- contains structures representing exceptions.

- contains structures for system input and output through data streams and the file system

- contains structures to handle JSON Web Token (JWT)

- contains structures for implementing networking services

- contains structures that provide support for HTTP calls

- contains structures that provide support for SOAP calls

- contains structures to operate with S3 service

- contains structures to operate with SQL queries

- contains PostgreSQL specific structures

Data Structure Builder
pdk.core
pdk.asset.dictionary
pdk.asset.scorecard
pdk.blockchain
pdk.ex
pdk.io
pdk.jwt
pdk.net
pdk.net.http
pdk.net.soap
pdk.s3
pdk.sql
pdk.db.postgre
inherits
parameterized
checked exceptions
pdk.ex.Exception
pdk.core.Any
pdk.core.UserObject