Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.activeviam.com/llms.txt

Use this file to discover all available pages before exploring further.

Measures are central to how Atoti aggregates and analyzes data. They represent numerical computations based on data available to the cube. A measure can range from simple aggregations like sums to more sophisticated user-defined logic.

​
Which types of measures does Atoti support

Atoti supports several types of measures, each suited to different analytical needs:

​
Aggregated measures

Aggregated measures are derived from numerical values in the original table. Common aggregation functions include:
  • SUM
  • AVG
  • MIN
  • MAX
For a full list of available aggregate functions see These functions operate over schema fields and are typically used to compute totals, averages, or other basic statistics.

​
Store look-up measures

Store look-up measures provide contextual information that supports other calculations within the cube. They are typically used to enrich analytical logic in user-defined measures (see below).
  • Store look-up measures provide reference data such as conversion rates or classification label, without affecting the core aggregation logic
  • The reference data is sourced from isolated tables in the database.
  • These tables are not part of the main fact table but are linked through mappings or relationships.
    For example, in a foreign exchange scenario, a look-up measure finds the exchange rate for the currency used in a financial transaction.

​
User-defined measures

User-defined measures allow for custom calculations beyond basic aggregations. For example:
  • Non-linear operations
  • Conditional logic
  • A combination of multiple aggregated measures
  • A combination of aggregated measures, look-up measures and other user-defined measures
Each individual measure generates value based on the data in the cube. The values are used by:
  • Business users to analyze data using Atoti UI or other tools
  • Other Atoti user-defined measures to create further measures in Atoti’s cube
Consider a primitive measure such as pnl.SUM which is the sum of the pnl field. This measure cannot aggregate correctly on the currency hierarchy. This limitation is one reason why the currency hierarchy is often treated as a slicing hierarchy. See the hierarchies documentation page for more details. To address this issue, the following pattern can be used:
  • Create a measure called pnl and make it visible to users.
  • When the query is filtered to USD, pnl delegates directly to pnl.SUM.
  • When the query is filtered to another currency XxX, define additional measures:
    • A lookup measure that retrieves the forex rate between XxX and USD from the isolated forex store.
    • A conversion measure that multiplies pnl.SUM by this forex rate.
This approach ensures a consistent and correct aggregated result across all currencies.

​
How does Atoti combine measures?

Measures are combined into a measure chain, where each measure builds upon the previous one.
Measures chain
Atoti supports core mathematical operations for combining measures, such as:
  • plus
  • minus
  • multiply
  • divide
These operations can be applied across measures to form new ones, enabling flexible and reusable logic. Find out how to create measures using:

​
How can measure calculation be refined with Atoti?

In Atoti, measures can be refined using filters and conditional logic, logical-level aggregation, and measure shifting. These techniques allow users to tailor calculations to specific data subsets, hierarchy levels, or time periods. This ensures that each measure reflects only the relevant data, helping users exclude outliers, compare time slices, and analyze specific members or groups within a hierarchy. By refining how measures are calculated, users gain more accurate insights without modifying the underlying dataset.

​
Filters and conditional logic

Measures in Atoti can include filters or conditional logic to control which data is used in calculations. This ensures that each measure reflects only the relevant subset of data. In other words, data from only specific hierarchy levels is used to calculate the value of the measure. In this way, users can create focused, accurate calculations without needing to adjust the underlying dataset. This is useful for: Excluding data such as:
  • Outliers
  • Test data
  • Data received after the start of day
  • Specific members that could cause double counting
Including data such as:
  • Only selected members of a hierarchy
  • Start-of-day data for comparison with intraday updates
Comparing data such as:
  • Comparing a subset of members with the total across a hierarchy
  • Comparing different time slices, like start-of-day versus current values
Find out how to apply filters to measures using:

​
Logical-level aggregation

Atoti supports logical-level aggregation. Measures can retrieve the value of other measures at a specific level of a hierarchy. This is useful for:
  • Grand totals: the sum of all the individual member values
  • Parent values: the sum of all the individual members up to a given level
  • Percentages or ratios
Find out how to apply conditional logic to measures using:

​
Measure shifting

Measure shifting allows for comparisons across time periods or across different hierarchy members. This is useful for:
  • Day to day differences: the value from day -1 is shifted to day -2
  • Comparing risk exposure across business units: credit risk exposure from counterparty A is shifted to counterparty B
  • Comparing capital allocation by business unit: capital allocation from desk Y is shifted to desk Z
Shifting values along dates is also used for building a timeline of prices or values. Find out how to shift measures using:

​
How does Atoti handle null values?

Atoti’s aggregation functions have consistent null handling behavior:
  • Null values are ignored in calculations
  • If all input values are null, the result is empty
This default behavior is consistent across both the Java and Python SDKs, ensuring stable and reliable calculations even when working with incomplete datasets. Developers can also implement their own logic within user-defined measures to treat nulls differently, such as substituting a default value. Find out how to manage nulls using: