14 Adopt Hybrid Mode for Fast Analytic Processing

The Oracle Essbase calculation and query processor enables you to perform real-time analytics using procedural calculations and read-and-write modeling capabilities.

If you have worked with Essbase 11g On-Premise, then you likely are familiar with one or more of these cube design modes, tailored for different purposes:

  • Block storage: best used when there are large, sparse dimensions. Cubes in this mode are stored and pre-aggregated to achieve good query performance. Includes a rich set of calculation functions for analysis.
  • Aggregate storage: best used for cubes having a large number of dimensions, and many upper-level aggregations. Member formulas can be specified using MDX.
  • Hybrid mode: block storage mode enhanced with the benefits of aggregate storage.

Hybrid mode is the default query engine for dynamic dependency analysis on block storage cubes in Essbase 21c, Essbase 19c, and Oracle Analytics Cloud - Essbase. Hybrid mode provides robust dependency analysis and fast aggregation. It is excellent at handling the complexity of querying members that have dependencies on dynamic members.

In your analytic applications, Oracle recommends the use of dynamic dependencies, including sparse aggregations. You are not limited to implementing Dynamic Calc selectively on sparse dimensions, as was the case in Essbase 11g On-Premise. In particular, sparse dynamic aggregations are possible and recommended, subject to performance tuning guidelines and testing.

Though hybrid mode is the default query processor for block storage cubes, it is not the default for executing calculation scripts. If your calculation scripts contain many dynamic dependencies, Oracle recommends you enable hybrid mode for calculation scripts as well. The way to do this is to turn on the HYBRIDBSOINCALCSCRIPT configuration setting in your application configuration properties (or use the SET HYBRIDBSOINCALCSCRIPT calculation command to control it on a per-calculation basis).

Most Essbase calculation functions will operate in hybrid mode. To see a list and syntax for all hybrid mode-supported calculation functions, as well as the few exceptions, see Functions Supported in Hybrid Mode. Parallel calculation using FIXPARALLEL is supported in hybrid mode, but not parallel calculation using CALCPARALLEL.

See ASODYNAMICAGGINBSO for the syntax to configure hybrid mode beyond the default settings, or to turn it off.

Topics in this section:

Benefits of Hybrid Mode

Hybrid mode combines block storage procedural calculation and write back functionality with aggregate storage aggregation performance. Hybrid mode offers the benefit of fast performance by eliminating the need to store sparse aggregations. This, in turn, reduces database size and memory footprint, and speeds up batch calculation times. The deployment considerations are simplified, as you no longer have to consider using block storage for heavy use of level 0 calculations, versus aggregate storage for many upper-level aggregations, versus designing partitioned models in which the cube is split along dimensional lines to facilitate calculation performance.

The following are some scenarios where hybrid mode is likely to improve calculation performance:

  • A block storage database has sparse members that are not level 0, and are calculated according to hierarchy (rather than by calculation scripts).

  • A sparse, dynamic calc parent member has more than 100 children.

  • You are using a transparent partition between an empty aggregate storage target and a block storage source. If the formulas on the aggregate storage target are simple and translatable to block storage formula language, you can achieve fast results on block storage using hybrid mode.

  • You are using a transparent partition between two block storage databases, and calculation performance is a concern.

Another benefit of hybrid mode is that it enables you to use scenario management.

Comparison of Hybrid Mode, Block Storage, and Aggregate Storage

Without hybrid mode, the block storage algorithm for Dynamic Calc members has limitations when used with large, sparse dimensions. Hybrid mode (and aggregate storage) are more optimized for dynamic dependency analysis. Read about key differences to help you choose the best query processor type for an Essbaseapplication.

Without hybrid mode, large, sparse dimensions in block storage databases must be stored; making them dynamic would result in too much block I/O at query or calculation time, affecting performance. Very large stored sparse dimensions can lead to lengthy batch aggregation times, as well as large database sizes that grow in relation to the number and size of the sparse dimensions. Even with such drawbacks, block storage is widely used for its powerful functionality.

Aggregate storage is designed specifically to enable large databases with more and larger dimensions. Unlike block storage, it does not require large sparse dimensions to be pre-aggregated to achieve good query performance. The key lies in the aggregate storage database kernel, which facilitates rapid dynamic aggregation across large dimensionality.

For all the benefits that aggregate storage offers, however, there are many applications that are better suited to block storage, such as the ability to load data at any granularity, or to frequently run complex batch allocations, or implement currency conversion for global financials. In such cases, and many more, hybrid mode might be the solution. Hybrid mode is a combination of the best features of block storage and aggregate storage. In hybrid mode, Essbase

  • Enables full procedural calculation flexibility, even when the calculations depend on sparse, dynamic aggregations.

  • Uses the hybrid engine for queries accessing dynamic sparse members. For the small percentage of queries that cannot be processed this way, Essbase employs the block storage calculation flow to satisfy the request.

  • Offers these benefits, if you mark sparse members as dynamic:

    • Eliminates the need for pre-aggregation
    • Improves restructure performance

    • Improves backup performance

    • Reduces disk space requirements

  • Because hybrid mode involves dynamic calculations, you can sequence the calculations by using solve order.


Hybrid calculations, whether driven by queries or calculation scripts, are performed in temporary memory space, utilizing a formula cache and the aggregate storage cache.

Key Differences

The following key differences can help you choose the best query processor type for your application.

Requirement Aggregate Storage (ASO) Block Storage (BSO) Hybrid Mode

Optimized for rapid aggregation across many sparse dimensions




Optimized for minimal disk space usage and reduced backup time




Optimized for financial applications




Ability to perform allocations




Ability to perform batch calculations




Member formulas supported

Yes, expressed as MDX

Yes, expressed as Essbase Calculation Functions

Yes, expressed as Essbase Calculation Functions

Optimized for forward references in member formulas




Ability to customize solve order of calculations/aggregations




Solve Order in Hybrid Mode

Ability to specify bottom-up query execution for faster dependency analysis of smaller input data sets




QUERYBOTTOMUP configuration setting

@QUERYBOTTOMUP calc function

Ability to trace and debug query execution






Ability to limit memory use permitted for a query






Support for two-pass calculation




Ability to load data at any level

No. Only level 0 cells without formula dependencies can be loaded


Yes for stored levels

No for dynamic levels

Ability to load data incrementally using buffers




Evaluation of formulas on sparse dimensions can have different results than same formulas on dense dimensions


Yes. On block storage without hybrid mode, Essbase calculation scripts may be written iteratively with the purpose of resolving dependencies over sparse blocks. If you change the dimension type from sparse to dense or vice versa, you may get different results for the same formulas.

No. Formula dependencies are calculated the same without regard to sparsity or density.

In hybrid mode, Essbase uses an algorithm to resolve dynamic dependencies. In some cases, the data derived from a calculation script may be different in hybrid mode than it would be in block storage mode without hybrid.

Get Started with Hybrid Mode

To get started with hybrid mode, follow these guidelines:

  • Set up a development environment, and migrate existing block storage applications to it. Hybrid mode is enabled by default for block storage cubes.

  • Where possible, make larger sparse dimensions dynamic.

  • Run test queries and examine the application log, both before and after enabling hybrid mode. This activity can reveal the extent to which the aggregate storage query processor was used, and the benefits of hybrid mode that were gained. For each query, the application log states Hybrid aggregation mode enabled or Hybrid aggregation mode disabled.

  • If too many queries are logged with hybrid mode disabled, contact Oracle Support.

Optimize the Cube for Hybrid Mode

To use hybrid mode most effectively:

  • Avoid using two-pass calculation in hybrid mode. Use solve order instead.

  • Convert non-level-0 stored members to Dynamic Calc wherever this is feasible.

  • If the conversion to Dynamic Calc members affects solve order for dependent formulas, you may need to adjust the outline's order of dimensions to align the solve order with the previous batch calculation order and two-pass calc settings.

    The default solve order for hybrid mode cubes is similar to the calculation order of block storage cubes, with some enhancements. If you wish to use a non-default solve order, you can set a custom solve order for dimensions and members.

  • A dynamically calculated formula processed in the wrong solve order can cause too many formulas to be executed by a query, degrading performance. When possible, a dynamically calculated sparse formula should have a higher solve order than hierarchically aggregated sparse dimensions.

    In some applications, this is not possible, as a different solve order is necessary to get the correct formula results. For example, an application with units and prices needs to have a sales value executed before the sparse aggregations in order to get the correct sales value at upper levels.

  • You may need to adjust the dimensions' dense or sparse configurations (applies only to block-storage engine utilization in cases where the hybrid engine cannot be used).

  • Minimize the size of blocks, if possible.

Essbase administrators can use the following tools to monitor and optimize query performance in hybrid mode:

  • To limit how much memory may be consumed by any single query, use the MAXFORMULACACHESIZE configuration setting.

  • If your cube has complex member formulas with cross-dimensional operators and multiple IF/ELSE statements, performance concerns may be related to formula execution. If this is suspected, you can activate bottom-up query processing for formula calculation. This optimizes query times by identifying the required intersections for calculation, making the query time proportional to input data size.

    To make these query optimizations for Release 21C, use the QUERYBOTTOMUP configuration setting, as well as the @QUERYBOTTOMUP calculation function. For Release 19C, use the IGNORECONSTANTS configuration setting with BOTTOMUP syntax, as well as the @NONEMPTYTUPLE calculation function.

  • Use query tracing to monitor and debug query performance. Multiple application-level configuration settings are available, depending on your use case. Use QUERYTRACE for short term debugging of a single query that you think might be problematic. Use TRACE_REPORT for statistics collection about concurrently running queries (ideal for debugging in a development environment). Use LONGQUERYTIMETHRESHOLD in production environments to print statistics to the application log file about any queries that run longer than a set time.

Limitations and Exceptions to Hybrid Mode

In some cases, a query would not execute optimally in hybrid mode. Essbase detects when these conditions are present, and aggregates them in block storage mode. If a query mixes supported and unsupported hybrid mode calculation types, Essbase defaults to block storage calculation execution.

If enabled, hybrid mode is in effect for member formulas using supported functions. For a list of supported and unsupported functions, see Functions Supported in Hybrid Mode.

The following types of queries are not executed in hybrid mode:

  • Dynamic Calc members with formulas that are a target of transparent partitions

  • Queries where the shared member is outside the target partition definition and its prototype member is inside, or the reverse


  • Text measures/text lists

Attribute calculations will execute in hybrid mode, for Sum only.

If dependent members have a higher solve order than the formula member, the following warning appears:

Solve order conflict - dependent member member_name with higher solve order will not contribute value for formula of member_name

Solve Order in Hybrid Mode

Solve order in Essbase determines the order in which dynamic calculation executes in hybrid mode. You can customize the solve order or accept the default, which is optimized for high performance and dependency analysis.

The concept of solve order applies to dynamic calculation execution, whether initiated by a dynamic member formula or a dynamic dependency in a calculation script. When a cell is evaluated in a multidimensional query, the order in which the calculations should be resolved may be ambiguous, unless solve order is specified to indicate the required calculation priority.

You can set solve order for dimensions or members, or you can use the default Essbase solve order. The minimum solve order you can set is 0, and the maximum is 127. A higher solve order means the member is calculated later; for example, a member with a solve order of 1 is solved before a member with a solve order of 2.

When hybrid mode is enabled, the default solve order (also known as calculation order) closely matches that of block storage databases:

Dimension/Member Type Default Solve Order Value
Stored members 0
Sparse Dimension Members 10
Dense Account dimension members 30
Dense Time dimension members 40
Dense regular dimension members 50
Attribute dimension members 90
Two pass dynamic members 100
MDX calculated members or named sets (defined in MDX With) 120

In summary, the default solve order in hybrid mode dictates that stored members are calculated before dynamic calc members, and sparse dimensions are calculated before dense dimensions, in the order in which they appear in the outline (top to bottom).

Dynamic members (with or without formulas) that do not have a specified solve order inherit the solve order of their dimension, unless they are tagged as two pass.

Two-pass calculation is a setting you can apply, in block storage mode, to members with formulas that must be calculated twice to produce the correct value. Two pass is not applicable in hybrid mode, and any members tagged as two pass are calculated last, after attributes. In hybrid mode, you should implement a custom solve order, instead of two pass, if the default solve order does not meet your requirements.

The default solve order in hybrid mode is optimized for these scenarios:

  • Forward references, in which a dynamic member formula references a member that comes later in the outline order. There is no outline order dependency in hybrid mode.

  • Aggregation of child values based on outline order more closely matches aggregation using equivalent formulas.

  • Dynamic dense members as dependencies inside sparse formulas. In hybrid mode, if a sparse formula references a dense dynamic member, the reference is ignored, because sparse dimensions are calculated first. To change this, assign a solve order to the sparse dimension that is higher than (calculated later than) the dense dimension’s solve order.

Customizing the Solve Order

If you need to adjust the behavior of dynamic calculations in hybrid mode, customizing the solve order of dimensions and members helps you achieve it without making major changes to the outline.

If you implement a custom solve order, it overrides the default solve order. If members or dimensions have equal solve order, the order in which they appear in the outline (top to bottom) resolves the conflict.

Unless you customize a solve order for certain members, the top dimension member's solve order applies for all dynamic members in the dimension.

To change the solve order, use the outline editor in the Essbase web interface, or use Smart View (see Changing the Solve Order of a Selected POV).

The minimum solve order you can set is 0, and the maximum is 127. A higher solve order means the member is calculated later.

To explore use cases for solve order, see the Solve Order templates in the Technical section of the gallery of application workbooks, which you can find in the files catalog in Essbase.

Notes on Solve Order in Non-hybrid Mode

In aggregate storage cubes,

  • Solve order is set to 0 for all dimensions.

  • Aggregation executes in outline order, except:

    • Stored hierarchy members are processed first.
    • Dynamic hierarchy members are processed next.

In non-hybrid block storage cubes, the default solve order is

  • sparse before dense

  • accounts before time

  • attributes last

For full details, see Calculation Order for Dynamic Calculation


If Accounts members' solve order are set manually to be greater than Time members' solve order, the Accounts will be evaluated after Dynamic Time Series members.