func (this *IntermediateGroup) processItem(item value.AnnotatedValue, context *Context) bool {
// Generate the group key
var gk string
if len(this.plan.Keys()) > 0 {
var e error
gk, e = groupKey(item, this.plan.Keys(), context)
if e != nil {
context.Fatal(errors.NewEvaluationError(e, "GROUP key"))
return false
}
}
// Get or seed the group value
gv := this.groups[gk]
if gv == nil {
gv = item
this.groups[gk] = gv
return true
}
// Cumulate aggregates
part, ok := item.GetAttachment("aggregates").(map[string]value.Value)
if !ok {
context.Fatal(errors.NewInvalidValueError(
fmt.Sprintf("Invalid partial aggregates %v of type %T", part, part)))
return false
}
cumulative := gv.GetAttachment("aggregates").(map[string]value.Value)
if !ok {
context.Fatal(errors.NewInvalidValueError(
fmt.Sprintf("Invalid cumulative aggregates %v of type %T", cumulative, cumulative)))
return false
}
for _, agg := range this.plan.Aggregates() {
a := agg.String()
v, e := agg.CumulateIntermediate(part[a], cumulative[a], context)
if e != nil {
context.Fatal(errors.NewGroupUpdateError(
e, "Error updating intermediate GROUP value."))
return false
}
cumulative[a] = v
}
return true
}
func (this *InitialGroup) processItem(item value.AnnotatedValue, context *Context) bool {
// Generate the group key
var gk string
if len(this.plan.Keys()) > 0 {
var e error
gk, e = groupKey(item, this.plan.Keys(), context)
if e != nil {
context.Fatal(errors.NewEvaluationError(e, "GROUP key"))
return false
}
}
// Get or seed the group value
gv := this.groups[gk]
if gv == nil {
gv = item
this.groups[gk] = gv
aggregates := make(map[string]value.Value, len(this.plan.Aggregates()))
gv.SetAttachment("aggregates", aggregates)
for _, agg := range this.plan.Aggregates() {
aggregates[agg.String()] = agg.Default()
}
}
// Cumulate aggregates
aggregates, ok := gv.GetAttachment("aggregates").(map[string]value.Value)
if !ok {
context.Fatal(errors.NewInvalidValueError(
fmt.Sprintf("Invalid aggregates %v of type %T", aggregates, aggregates)))
return false
}
for _, agg := range this.plan.Aggregates() {
v, e := agg.CumulateInitial(item, aggregates[agg.String()], context)
if e != nil {
context.Fatal(errors.NewGroupUpdateError(e, "Error updating initial GROUP value."))
return false
}
aggregates[agg.String()] = v
}
return true
}
func (this *FinalGroup) processItem(item value.AnnotatedValue, context *Context) bool {
// Generate the group key
var gk string
if len(this.plan.Keys()) > 0 {
var e error
gk, e = groupKey(item, this.plan.Keys(), context)
if e != nil {
context.Fatal(errors.NewEvaluationError(e, "GROUP key"))
return false
}
}
// Get or seed the group value
gv := this.groups[gk]
if gv != nil {
context.Fatal(errors.NewDuplicateFinalGroupError())
return false
}
gv = item
this.groups[gk] = gv
// Compute final aggregates
aggregates := gv.GetAttachment("aggregates")
switch aggregates := aggregates.(type) {
case map[string]value.Value:
for _, agg := range this.plan.Aggregates() {
v, e := agg.ComputeFinal(aggregates[agg.String()], context)
if e != nil {
context.Fatal(errors.NewGroupUpdateError(
e, "Error updating final GROUP value."))
return false
}
aggregates[agg.String()] = v
}
return true
default:
context.Fatal(errors.NewInvalidValueError(fmt.Sprintf(
"Invalid or missing aggregates of type %T.", aggregates)))
return false
}
}
