1. Abstract
Users often need to configure mapping cubes across applications in Board to maintain one to one relationships to entities.
However, when these entities contain a large number of members, manually selecting or updating mappings directly in the mapping cube becomes cumbersome and error-prone.
This article explains how to efficiently manage mappings between two entities using a Text Cube as an intermediary input layer. This method allows users to control mappings through a simplified interface and automatically update the mapping cube via a Procedure.
2. Context
In large Board applications, mapping cubes are used to maintain one to one or many to one relationship between two entities such as:
- Regions → Sales Areas
- GL Accounts → Cost Centers
When entities contain thousands of members, manually mapping members between entities directly in the mapping cube in a layout displaying all the members of the entities, it can lead to:
- Performance inefficiencies
- Higher risk of data inconsistencies
- Greater potential for user error
3. Content
Instead of allowing users to edit the mapping cube directly — which can be inefficient when loading all members in rows and columns— this method introduces a Text Cube as a temporary selection layer.
- Users select the target entity member from a dropdown list (configured with Suggested Values based on the target entity’s Code and Description).
- Upon confirmation (e.g., clicking “Save Mapping”), a Procedure writes the selected value from the Text Cube into the actual mapping cube.
This approach provides an efficient and secure way to manage large mappings while maintaining control and performance.
3.1 Implementation Steps
We consider a scenario where we have a many to one relationship between Job Title and GL Accounts (Financial Accounts).
The typical approach of managing this relationship directly in the mapping cube layout would look as follows: a very large, and difficult to read, dataview with GL account by row and Job Title by column. The mapping is done by flagging the related combination of GL Account vs Job Title.
The alternative way to manage the same mapping is by implementing the following logic and setting the relationship, having the user select a GL Account from a drop-down list, for each Job Title by following the steps. This enhances the user experience but requires some additional configuration in the back end.
3.1.1 Create Mapping Cubes
- Text Cube: Create a Text Cube (e.g., MAP_DAT_DE_Text Map GL Account to Job Title), dimensioned by the source entity (e.g., Job Title).This cube temporarily stores the user’s selected target member (as text) at the other mapping entity level.
- Integer Cube: Create an Integer Cube to store the actual mapping between the GL Account and Job Title.
3.1.2 Build a Layout for User Selection
- Add the Text Cube (MAP_DAT_DE_Text Map GL Account to Job Title) to the layout.
- Set Rows = Job Title (Source Entity).
- Add a Dropdown Selector for valid target entity members:
- Use Suggested Values = Target entity’s Code + Description (e.g., GL Code and GL Description). This ensures users can only select valid and relevant members.
- Add a Color Alert to highlight missing mappings.
3.1.3 Create a Procedure to Update the Mapping Cube
Develop a procedure to automatically update the mapping cube. Suggested steps:
- Save Data Entry: Save the user input from the Text Mapping Cube.
- Data Flow
- Write the selected member from the Text Cube into the Integer Mapping Cube (e.g., MAP_DAT_DF_GL Account to Job Title).
- Use a comparison logic to match Text Cube entries with the entity codes/descriptions and write a value of 1 when matched.
- Refresh Screen: Refresh the layout to display updated mappings.
Example: Mapping between Job Title and GL Code
- Layout: includes the Text Cube at Job Title level.
- Target Entity: GL Code (Code + Description).
- Mapping Logic Example:
Steps:
Layout for dataflow:
! Note: Extend the tuples for both GL Account and Job Title as needed.
3.2 Advantages
- Performance: Users interact with a Text Cube instead of a large mapping cube.
- Security: The actual mapping cube remains protected from direct editing.
- Scalability: Handles large entity lists efficiently (thousands of members).
Another Example Use Case
Scenario: Mapping “Customer” to “Region”
Step | Component | Description |
|---|
1 | MAP_DAT_Text_Customer_Region | Text Cube (dimensioned by Customer) |
2 | UI Layout | Dropdown for selecting Region(Code and Description) |
3 | Procedure | Writes the selected Region into the final mapping cube MAP_Customer_to_Region |
Result:
Users simply select the Region for a Customer from the drop-down, run the Procedure (via a button click), and the mapping is automatically updated — fast, clean, and secure.
Note:
Since a one-to-one mapping between Customer and Region is required, this approach is suitable.
3.3 Conclusion
Using a Text Cube with a procedure-driven mapping process streamlines and simplifies the management of relationships between two entities with many members. This approach is scalable, provides great user experience and reduces user errors.
