/* This method takes in an operand value and context and returns a value. If the type of operand is missing then return it. If the operand type is AnnotatedValue then we call NewValue using the GetAttachment method on the operand with input string meta. In the event the there is no attachment present, the default case is to return a NULL value. */ func (this *Meta) Apply(context Context, operand value.Value) (value.Value, error) { if operand.Type() == value.MISSING { return operand, nil } switch operand := operand.(type) { case value.AnnotatedValue: return value.NewValue(operand.GetAttachment("meta")), nil default: return value.NULL_VALUE, nil } }
/* Retrieve the set for annotated values. If the attachment type is not a set, then throw an invalid distinct set error and return. */ func getSet(item value.Value) (*value.Set, error) { switch item := item.(type) { case value.AnnotatedValue: ps := item.GetAttachment("set") switch ps := ps.(type) { case *value.Set: return ps, nil default: return nil, fmt.Errorf("Invalid DISTINCT set %v of type %T.", ps, ps) } default: return nil, fmt.Errorf("Invalid DISTINCT %v of type %T.", item, item) } }
/* Directly call the evaluate method for aggregate functions and passe in the receiver, current item and current context, for count with an input expression operand. For a count with no operands (count (*)), get the count from the attachment and then evaluate. */ func (this *Count) Evaluate(item value.Value, context expression.Context) (result value.Value, e error) { if this.Operand() != nil { return this.evaluate(this, item, context) } // Full keyspace count is short-circuited switch item := item.(type) { case value.AnnotatedValue: count := item.GetAttachment("count") if count != nil { return value.NewValue(count), nil } } return this.evaluate(this, item, context) }