Techniques for Creating, Loading, and Optimizing a Simple Essbase ASO Application
A couple of recent projects have required us to build an Essbase database to provide a subset of upstream system data for downstream consumer systems such as Hyperion Profitability and Cost Management (HPCM). The process included dimension updates, data loads and custom calculations. Essabase Aggregate Storate Option (ASO) was the chosen Essbase technology because we were potentially dealing with large data volumes, relatively simple hierarchy structures, and only a small number of custom calculations that could be easily modeled in MDX within minimal performance impact.
The principle was that an overnight batch would be used to completely rebuild the ASO cube each night, including any metadata restructures that were necessary, followed by a full reload of data.
The high level process is as follows:
The starting point was to use a 'stub' application as a template for the metadata rebuild. This is an ASO Essbase application with all dimension headers present, all POV dimensions present (Years, Periods, Scenarios etc), and all volatile hierarchies represented by the hierarchy headers only. This ASO application serves as a “poor man’s MDM” which allows us to have application, dimension and hierarchy properties all pre-set. The main advantage of the stub outline is that it creates a natural defragmentation of the target ASO application which improves query performance, and reduces dimension build times to the minimum. This is analogous to a relational database where you want to 'truncate' tables and/or compress, as opposed to deleting and reading all the time – there is a gradual growth. A good tip is to defragment build dimensions in order from smallest to largest in terms of volumes.
A sample 'Stub.otl' outline looks something like the following. In this case, the stub outline is modeled after the new embedded Fusion G/L Essbase cube:
As can be seen, the volatile dimensions (Budget centre, Balancing Entity, Accounts, etc) are each populated with a single hierarchy header (e.g. BE_dummy) whereas the static dimensions (AccountingPeriod, Balance Amount etc) are complete, and will not be the subject of a dimension load in the MaxL. Static dimensions which contain members with MDX member formula will persist (although the formula will not necessarily validate at this stage as they may depend on members that have not yet been rebuilt).
The first part of the batch process is to use this Stub outline to replace the outline in the 'user' ASO cube (i.e. the cube that will be restructured and loaded with data). The MaxL will clear data & replace the .otl file in the user application with the .otl file from the 'stub' application
A simplified version of the MaxL is as follows (normally passwords would be encrypted):
This simply copies the Stub.otl file into the 'user' ASO cube database folder & names it with the target database name - it will be available as soon as the application is reloaded.
The next section in the MaxL would be a standard dimension build of those volatile dimensions - the primary consideration when building the hierarchies is that the ASO restrictions on hierarchies are met otherwise the outline will not verify. This is not covered here - we assume that incoming master data is pre-validated to meet these requirements, but the summary of dimension rules for ASO is as follows:
- ASO dimensions can contain hierarchies of 2 types - 'Stored' or 'Dynamic'
- A dimension must be tagged as Multiple Hierarchies Enabled' or “Dynamic” if it contains two or more hierarchies
- The first hierarchy in a dimension where Multiple Hierarchies enabled is specified must be defined as a 'Stored' hierarchy
- Stored Hierarchies are generally only additive as they only allow the + or ~ consolidation operators
- Dynamic Hierarchies can contain any consolidation operators, and members can contain formulas.
- For alternate hierarchies, where shared members may be required, Stored hierarchies can only contain one instance of a member (to avoid double counting), but subsequent Stored hierarchies can contain members previously defined in previous stored hierarchies
Once metadata has been loaded, the dataload can be carried out.
Once this is complete, we have a fully loaded ASO cube, which we can retrieve data against using either SmartView or an Essbase report script (for example, when we are supplying filtered data to our downstream systems).
The example Smart View retrieve template below is a straightforward report with periods as columns and 550 rows of level 0 Budget Centres, with all other dimensions set as filters.
The Essbase application log shows that the above SmartView query took over 16s to execute. This report layout may or may not be representative of real world queries / reports but the object of the exercise here is to speed this up for in-day usage.
ASO databases do not use calculation scripts to consolidate the data so the traditional BSO approach to consolidation cannot be used. Instead, ASO will attempt to dynamically calculate upper level intersections, which, while resulting in much faster batch processing times, may result in longer than necessary retrieval times.
What we can do to improve this situation is use the 'Query Tracking' facility in ASO to capture the nature of queries run against the ASO cube, and build retrieval statistics against it. These statistics can then be used to build aggregation views tailored to retrieval patterns in the business.
This relies on us having some predefined definitions of the kinds of queries that are likely to be run - SmartView report templates, Web Analysis pages & Financial Reports definitions will all be suitable.
In this example, we use the above SmartView template as a basis for creating an Essbase Report script as follows:
This report mimics the SmartView template, and we use it during the overnight batch to capture the query characteristics using Query Tracking. One of the reasons to use report scripts is that if you use the query designer (or the Spreadsheet Retrieval Wizard if you are using a REALLY old version of the Excel Add In), it can save a report script output. MDX queries will have a similar affect.
The sequence of MaxL steps is as follows:
- Switch on Query Tracking
- Run one or more Essbase Report Script(s)
- Run 'execute aggregate process' command to create aggregate views
The MaxL to accomplish this is as follows:
The 'execute aggregate process' command is issued with the ' based on query_data' option to tell Essbase to use query patterns picked up by Query Tracking to build the aggregation views. Essbase will build as many views as necessary until the 'total_size' limit is reached. This limit may need tweaking so as to give the desired improvement in performance whilst also conserving disk space (which may get swallowed up with larger ASO cubes). The particular example also runs in a matter of seconds, but the addition of more sample reports needs to be managed to ensure that the batch run time does not exceed its window. It should be noted that one can process hierarchies without the query tracking, but there are restrictions on what alternate hierarchies get processed, and this is a very good technique when you are trying to improve performance on "alternate rollups".
When this has been executed, users should see an improvement on query performance.
Our SmartView query was rerun, and the log file demonstrates the reduction in query time to less than 1 second :
This approach lends itself to situations where the ASO outline is likely to change frequently. Changes in metadata mean that aggregation views created and saved in EAS cannot necessarily be reused - new level 0 members will not necessarily invalidate the aggregate views, but new upper level members, or restructured hierarchies definitely will invalidate these views. The rationale for this is because the ASO aggregation engine constructs multiple “jump” points based on the most recent level hierarchy - if I were going to oversimplify what was happening in a BSO world, imagine level zero stored, level one as dynamic calc, level two stored, level three as dynamic calc, and level four stored. In any instance, there would never be more than one level of dynamic calc. I don’t know if this is still the case, but this may be why ASO cubes seem to like symmetrical vs. ragged hierarchies a bit easier – it makes the derivation of what should be calculated vs. dynamic easier.