/*
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)
}