/*
This method evaluates the equal condition and returns a value
representing if the two operands are equal or not. If either
of the input operands are missing, return missing value, and
if they are null, then return null value. For all other types
call Equals to check if the two values are equal and return
its return value.
*/
func (this *Eq) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.MISSING || second.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if first.Type() == value.NULL || second.Type() == value.NULL {
return value.NULL_VALUE, nil
}
return value.NewValue(first.Equals(second)), nil
}
/*
This method checks to see if the values of the two input
expressions are equal, and if true then returns a null
value. If not it returns the first input value. Use the
Equals method for the two values to determine equality.
*/
func (this *NullIf) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.MISSING || second.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if first.Type() == value.NULL || second.Type() == value.NULL {
return value.NULL_VALUE, nil
}
if first.Equals(second) {
return value.NULL_VALUE, nil
} else {
return first, nil
}
}
/*
WITHIN evaluates to TRUE if the right-hand-side first value contains
the left-hand-side second value (or name and value) as a child or
descendant (i.e. directly or indirectly). If either
of the input operands are missing, return missing value, and if
the first operand is not an array and the second is not an object
return a null value. Range through the descendants of the second
value object, and check if the first value is equal to each
descendant; return true. For all other cases return false.
*/
func (this *Within) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.MISSING || second.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if second.Type() != value.ARRAY && second.Type() != value.OBJECT {
return value.NULL_VALUE, nil
}
desc := second.Descendants(make([]interface{}, 0, 64))
for _, d := range desc {
if first.Equals(value.NewValue(d)) {
return value.TRUE_VALUE, nil
}
}
return value.FALSE_VALUE, nil
}
/*
This method ranges through the array and returns the position
of the second value in the array (first value). If the input
values are of type missing return a missing value, and for all
non array values return null. If not found then return -1.
*/
func (this *ArrayPosition) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.MISSING || second.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if first.Type() != value.ARRAY {
return value.NULL_VALUE, nil
}
fa := first.Actual().([]interface{})
for i, f := range fa {
if second.Equals(value.NewValue(f)) {
return value.NewValue(float64(i)), nil
}
}
return value.NewValue(float64(-1)), nil
}
/*
IN evaluates to TRUE if the right-hand-side first value is an array
and directly contains the left-hand-side second value. If either
of the input operands are missing, return missing value, and
if the second is not an array return null. Range over the elements of the
array and check if any element is equal to the first value, return true.
For all other cases, return false.
*/
func (this *In) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.MISSING || second.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if second.Type() != value.ARRAY {
return value.NULL_VALUE, nil
}
sa := second.Actual().([]interface{})
for _, s := range sa {
if first.Equals(value.NewValue(s)) {
return value.TRUE_VALUE, nil
}
}
return value.FALSE_VALUE, nil
}
/*
This method removes all the occurences of the second value from the
first array value. If the first value is MISSING or not an array,
then return missing or a null value. If the second value is missing
then return the first array value itself. Range through the array
and and check for the value, append all unequal values. Return the
final array.
*/
func (this *ArrayRemove) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if first.Type() != value.ARRAY {
return value.NULL_VALUE, nil
} else if second.Type() == value.MISSING {
return first, nil
}
fa := first.Actual().([]interface{})
ra := make([]interface{}, 0, len(fa))
for _, f := range fa {
if !second.Equals(value.NewValue(f)) {
ra = append(ra, f)
}
}
return value.NewValue(ra), nil
}
/*
This method appends the value into the array if it isnt
present. Range over the array and check if the value exists.
If it does return the array as is. If either of the input
argument types are missing, or not an array return a missing
and null value respectively.
*/
func (this *ArrayPut) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if first.Type() != value.ARRAY {
return value.NULL_VALUE, nil
} else if second.Type() == value.MISSING {
return first, nil
}
f := first.Actual().([]interface{})
for _, a := range f {
v := value.NewValue(a)
if second.Equals(v) {
return first, nil
}
}
ra := append(f, second)
return value.NewValue(ra), nil
}