Introduction

This approach assumes that the cache to be loaded was added with a payload variable for the cache key, and is comprised of multiple, single-record payloads (having been through a flow control shape).

Each of these payloads has its own, unique cache key (when data was added to the cache, this key was generated dynamically by resolving a cache key payload variable).

When we come to load this data, we must target the required cache keys. In the same way that we use a payload variable to add data to a cache with dynamic cache keys, we can use a payload variable to load data from these keys.

To do this, you configure a load from cache shape with a 'multi-pick' payload variable in the cache key, and ensure that data passed into this shape contains the values required to resolve this variable.

How it works

In summary, you can drop a single load from cache shape into a process flow and specify a payload variable as the required cache key. This must be in the form:

[[payload.*.<element>]]

...where <element> should be replaced with whichever data element you will be passing in to to resolve the cache key. For example:

[[payload.*.id]]

You then need to pass in any <element> values that should be used to resolve required cache key names. This might be achieved via a connection shape (if values are being generated from another system), or perhaps a manual payload shape. Whichever shape you use must be placed immediately before the load from cache shape.

Example

To help understand how this approach works, we will step through an example.

Suppose we have the scenario where a process flow has been built to receives incoming orders, and another process flow needs to target specific orders received from this flow.

Process flow 1: Add to cache To allow the second process flow access to orders processed by the first, we must add all incoming orders to a company type cache in the first process flow (remember that company type caches can be accessed by any other process flow created for your company profile). To ensure that we can go on to target specific orders from this cache later, we will cache every order in its own cache key, using a payload variable.

Process flow 2: Load from cache To retrieve specific orders from the cache created in the first process flow, we will pass the required order ids into a load from cache shape. These ids will be used to resolve dynamic cache keys, using a payload variable.

Process flow 1: Add to cache

Here, we will batch an 'orders' payload into single order payloads - then we'll add each payload to its own cache key, which is created dynamically from a payload variable. Let's break these steps down:

Process flow 2: Load from cache

Here, we will pass the required order ids into a load from cache shape. These ids are then used to resolve dynamic cache keys (via a payload variable) to determine which orders should be loaded. Let's break these steps down:

Introduction

This approach assumes that the cache to be loaded was added with a payload variable for the cache key, and is comprised of multiple, single-record payloads (having been through a flow control shape).

Each of these payloads has its own, unique cache key (when data was added to the cache, this key was generated dynamically by resolving a cache key payload variable).

When we come to load this data, we must target the required cache key. If you only want a single item, the quickest way is to specify the resolved cache key.

How it works

The load from cache shape works as normal - you choose the cache and cache key to be loaded:

However, the important point to consider is that the cache key that you specify here will have been generated dynamically by resolving the payload variable that was specified when the cache was added.

Example

Consider the following process flow:

Here, our manual payload contains customer data as below:

[
    {
        "id": 1000000001,
        "first_name": "Jane",
        "last_name": "Smith",
        "items": {
           "itemref": "0000001",
            "item1": "apples",
            "item2": "oranges",
            "item3": "pears"
        }
    },
    {
        "id": 1000000002,
        "first_name": "George",
        "last_name": "Jones",
        "items": {
           "itemref": "0000002",
            "item1": "tangerines",
            "item2": "peaches",
            "item3": "grapes"
        }
    },
    {
        "id": 1000000003,
        "first_name": "Bob",
        "last_name": "Brown",
        "items": {
           "itemref": "0000003",
            "item1": "nectarines",
            "item2": "raspberries",
            "item3": "strawberries"
        }
    },
    {
        "id": 1000000004,
        "first_name": "Marjorie",
        "last_name": "Simpson",
        "items": {
           "itemref": "0000004",
            "item1": "blueberries",
            "item2": "cranberries",
            "item3": "apricots"
        }
    }
]

To allow us to target specific customer records from this payload, we send it through a flow control shape, which is set to creating one payload for customer:

...so now we have lots of payloads to be cached:

If we look at the payload for the first of these, we can see it contains a single customer record - notice that there's an id field with a value of 1000000001. This field uniquely identifies each record.

Next we define an add to cache shape - we create a new cache and use a payload variable to generate a dynamic cache key for each incoming payload:

Here, they payload variable is defined as:

customer-[[payload.0.id]]

where:

• customer- is static text to prefix the resolved variable.

• [[payload.]] instructs the shape that this variable should be resolved from the incoming payload.

• 0 denotes that the first occurrence of the following item found in the payload should be used to resolve this variable.

• id is the name of the field in the payload to be used to resolve this variable

So, if we take our first payload above:

...our payload variable would resolve to the following cache key:

customer-1000000001

This is what we use in our load from cache shape:

Introduction

This approach is the simplest - all incoming data is cached with a static cache key.

How it works

In the example below, all incoming customer records will be added to a cache named ALLcustomers and a static cache key named customers:

When the data is cached, it's likely that the cache will include multiple records - for example:

To retrieve this cache, we simply drop a load from cache shape where required in the process flow and specify the same cache and cache key that were defined in the corresponding add to cache shape:

Load a single, targeted item from a dynamic cache key

This approach assumes The load from cache shape works as normal to retrieve cached data where the cache was created with a payload variable - you choose the cache name and key to be loaded:

However, the important point to consider is that the cache key that you specify here will have been generated from the payload variable that was specified when the cache was created.

If a payload variable has been used to cache data, you would typically have included a flow control shape to create multiple payloads - for example:

So you will have multiple cache keys that can be loaded. To do this, you can add one load from cache shape for every cache key that you want to retrieve, specifying the required key in each case. For example:

Alternatively, you can add a single load from cache shape and target specific cache keys by passing in the required ids.

Load multiple, targeted items from a dynamic cache key

Introduction

The load from cache shape is used to retrieve a stored payload from an existing cache key (created from an add to cache shape).

You might configure a load from cache shape in the same process flow as the original add to cache step or - if a cache was added and set to company level - you might choose to load it in a different process flow.

Adding & configuring a load from cache shape to a process flow

To add a load from cache shape to a process flow, follow the steps below.

Step 1 Find the point in your process flow where you want to load the payload from a cache - this could be at the very start of a process flow, or perhaps somewhere further down.

Step 2 Select the load from cache shape from the shapes palette:

Step 3 Click in the select cache field and choose which cache you want to retrieve:

Step 4 Enter the cache key that you want to retrieve - for example:

Your given cache key might be static or dynamic, depending on how the cache was configured in the corresponding add to cache shape:

For detailed information about each of these approaches, please see What cached data do you want to load?

Step 5 If you want this process flow to fail if for any reason this cache can't be retrieved, tick the fail on cache miss option:

If you leave this option un-ticked, the process flow will continue to run if the cache can't be loaded.

Step 6 If the cache that you're loading was created with the save all pages option toggled ON, you should toggle the load all pages option ON when loading this data:

Step 7 Save changes. The load from cache shape is added to your process flow, displaying the given name and key - for example:

Can I see the data associated with a load from cache shape?

Yes. As with any other process flow shape, you can view the associated payload for a load from cache shape after the process flow has run. To do this, click the shape's tick icon and then select the payload tab in the run log panel - for example:

Introduction

Loading data from a cache is very straightforward using the load from cache shape, however you do need to consider what data you want to load. You can:

Each of these options requires a slightly different approach, as summarised in the diagram below and explained in subsequent sections: