Rollups

One of the ways that jAgg supports super aggregation is by supporting rollups. Normally, jAgg calculates aggregate values based on all "group by" properties specified in the Builder object. However, sometimes different levels of aggregation are desired. For example, subtotals for each group of aggregate values can be desirable.

Once can simply call jAgg again, with less properties, to obtain the desired subtotals, but that would mean a separate pass through the data for each level of super aggregation. With rollups, and super aggregation in general, jAgg reuses the Aggregators that were used to calculate the original, normal aggregate values, in order to calculate the new super aggregate values.

Understanding Rollups

When rollups are specified, jAgg needs to know which properties by which to create subtotals. jAgg expects 0-based indices to specify which properties. These indices refer to the original list of property names that was supplied to the Builder object. jAgg will create subtotals first at the last specified property, then it will roll up those subtotals to the property specified before that last property, and so on, until all rollup properties have been subtotaled. Unlike cube, a rollup of n properties produces only n extra grouping set combinations.

In this example, four property names were originally specified to jAgg. Without rollups, normal aggregation proceeds and here are the results:

List<String> properties = Arrays.asList("property1", "property2", "property3", "property4");
List<Aggregator> aggs = Arrays.asList(Aggregator.getAggregator("Sum(value)"));
Aggregation agg = new Aggregation.Builder()
   .setProperties(properties)
   .setAggregators(aggs)
   .build();
List<AggregateValue<TestRec>> aggValues = agg.groupBy(testRecords);
            

Here are the new results when the following rollups are specified: {1, 2, 3}, corresponding to "property2", "property3", and "property4", respectively.

List<String> properties = Arrays.asList("property1", "property2", "property3", "property4");
List<Aggregator> aggs = Arrays.asList(Aggregator.getAggregator("Sum(value)"));
List<Integer> rollupProps = Arrays.asList(1, 2, 3);
Aggregation agg = new Aggregation.Builder()
   .setProperties(properties)
   .setAggregators(aggs)
   .setRollup(rollupProps)
   .build();
List<AggregateValue<TestRec>> aggValues = agg.groupBy(testRecords);
            

Subtotals are calculated at increasingly general levels. Note here that the order of the rollup properties specified is important, because the properties referenced last will get rolled up before the properties referenced first. Also, whenever a property is rolled up, its value is null, meaning that the particular aggregate value represents "all values" for this property.

Above, every property was subtotaled except for "property1", because "0" was not specified. Here is another example, including "property1". Because all properties are now specified, there is one AggregateValue where getPropertyValue always returns null. This is the grand total.

List<String> properties = Arrays.asList("property1", "property2", "property3", "property4");
List<Aggregator> aggs = Arrays.asList(Aggregator.getAggregator("Sum(value)"));
List<Integer> rollupProps = Arrays.asList(0, 1, 2, 3);
Aggregation agg = new Aggregation.Builder()
   .setProperties(properties)
   .setAggregators(aggs)
   .setRollup(rollupProps)
   .build();
List<AggregateValue<TestRec>> aggValues = agg.groupBy(testRecords);
            

Identifying Grouping Sets

If a certain property represents "all values", then the result from getPropertyValue for that property will be null. But what if null is the actual value being aggregated? jAgg tells these cases apart with the help of the methods isGrouping() and getGroupingId.

• isGrouping(int field) - Determines whether the property referenced by the given 0-based index represents "all values". If true, then getPropertyValue(field) returns null and this is a super aggregate value. If false, then getPropertyValue(field) can return any value, including null, and this aggregate value does not represent "all values" for this property.
• isGrouping(String propertyName) - Determines whether the given property represents "all values". If true, then getPropertyValue(field) returns null and this is a super aggregate value. If false, then getPropertyValue(field) can return any value, including null, and this aggregate value does not represent "all values" for this property.
• getGroupingId(List<?> fields) - Creates a distinct integer grouping set ID based on the referenced fields, which may be 0-based integer references or property name strings, or both. Every aggregate value that has the same properties representing "all values" has the same integer ID.

Here is the same example as above, but with the above method call results included.

Multiple Rollups

Multiple groups of rollups are possible. Each rollup combination is itself rolled up with every other rollup combination.

List<String> properties = Arrays.asList("property1", "property2", "property3", "property4");
List<Aggregator> aggs = Arrays.asList(Aggregator.getAggregator("Sum(value)"));
List<List<Integer>> rollupsProps = Arrays.asList(
    Arrays.asList(0, 1),
    Arrays.asList(2));
Aggregation agg = new Aggregation.Builder()
   .setProperties(properties)
   .setAggregators(aggs)
   .setRollups(rollupsProps)
   .build();
List<AggregateValue<TestRec>> aggValues = agg.groupBy(testRecords);