Skip to main content

The API

Atoti cube builder​

Copper calculations are specified in the withCalculations(Consumer<ICopperContext>) method available in the cube builder.

The entry point of Copper API is the "Copper context" or simply the "context", which is aware of the already defined measures and hierarchies. Copper measures and hierarchies are created with the API and then published to the context like so:

.withCalculations(
    context -> {
      // Here you can describe your calculations with the context
    });

The above snippet shows that all the Copper measures are defined in a single lambda method. For the sake of brevity, all examples from now on only show its body.

Once you have specified your calculations in the lambda, the new measures and hierarchies are added to the pivot description before it is started.

The Copper class provides all the static methods that serve as an entry point for measure and hierarchy creation. All created measures are objects that implement the same interface CopperMeasure, representing the basic bricks of Copper calculations that give you access to methods to build more complex calculations.

Inside the lambda itself, you may also reuse previously published measures or hierarchies for subsequent Copper calculations (pseudo-code):

CopperMeasure m1 = Copper.method(); // Create a measure with a static method from the Copper class
m1.publish(context);
// m1 is now available in following calculations

CopperMeasure m2 = m1.function(); // Apply function() on m1 to create a new measure
m2.publish(context);
// m2 is now available in following calculations

All your measures can be declared within this lambda, in Copper, at the same place and in the same way. This includes CopperMeasures, but also native measures, aggregated measures, as well as legacy post-processors.

Copper and distributed environments (experimental)​

For more information about Atoti's distributed architecture and its concepts, please refer to the following article about distribution.

This is feature is currently in experimental stage. The API and behaviors can change between bug fix releases.

Copper in Query Cubes​

You can use Copper in query cubes to declare measures that perform advanced calculations on measures defined in data cubes from applications that do not share the same topology.

This API is similar to the API that defines measure in a data cube with two key differences:

Measure to referenceUse
measure defined in a data cubeCopper.measureFromDataCube(measureName, measureType)
measure defined within the same query cubeCopper.measure(measureName)

CopperMeasure m1 = Copper.measureFromDataCube("measureFromDataCube1", ILiteralType.DOUBLE);
CopperMeasure m2 = Copper.measureFromDataCube("measureFromDataCube2", ILiteralType.LONG);
CopperMeasure m1_plus_m2 = m1.plus(m2).as("m1+m2").publish(context);
Copper.measure("m1+m2").multiply(Copper.constant(2)).as("multiply").publish(context);

The following features are yet to be implemented and will be available in future releases:

  • copperMeasure.shift(...)
  • copperMeasure.filter(...)

The features that need to access the database will not be supported: field aggregation, store lookup, join.

Copper in Data Cubes​

Distribution is expected to work seamlessly in data cubes with the Copper API, as there should be no properties or additional call required for measures to work as intended in a distributed environment and have their computations distributed if possible.

Limitations​

Continuous query on Copper measures that use Copper.storeLookup will not be notified on the updates in the database, because the Query Cube does not have access to the database.