/*
If the input argument type is greater than NULL, we return the complement
of its Truth() method's return type. If Null or missing return the argument
itself.
*/
func (this *Not) Apply(context Context, arg value.Value) (value.Value, error) {
if arg.Type() > value.NULL {
return value.NewValue(!arg.Truth()), nil
} else {
return arg, nil
}
}
/*
Aggregate distinct intermediate results and return them.
If no partial result exists(its value is a null) return the
cumulative value. If the cumulative input value is null,
return the partial value. Get the input partial and cumulative
sets and add the smaller set to the bigger. Return this set.
*/
func cumulateSets(part, cumulative value.Value) (value.Value, error) {
if part.Type() == value.NULL {
return cumulative, nil
} else if cumulative.Type() == value.NULL {
return part, nil
}
pset, e := getSet(part)
if e != nil {
return nil, e
}
cset, e := getSet(cumulative)
if e != nil {
return nil, e
}
// Add smaller set to bigger
var smaller, bigger *value.Set
if pset.Len() <= cset.Len() {
smaller, bigger = pset, cset
} else {
smaller, bigger = cset, pset
}
for _, v := range smaller.Values() {
bigger.Add(v)
}
cumulative.(value.AnnotatedValue).SetAttachment("set", bigger)
return cumulative, nil
}
/*
This method evaluates the Field using the first and second value
and returns the result value. If the second operand type is a
missing return a missing value. If it is a string, and the
field is case insensitive, then convert the second operand to
lower case, range through the fields of the first and compare,
each field with the second. When equal, return the value. If
the field is case sensitive, use the Field method to directly
access the field and return it. For all other types, if the
first operand expression is missing, return missing, else return
null.
*/
func (this *Field) Apply(context Context, first, second value.Value) (value.Value, error) {
switch second.Type() {
case value.STRING:
s := second.Actual().(string)
v, ok := first.Field(s)
if !ok && this.caseInsensitive {
s = strings.ToLower(s)
fields := first.Fields()
for f, val := range fields {
if s == strings.ToLower(f) {
return value.NewValue(val), nil
}
}
}
return v, nil
case value.MISSING:
return value.MISSING_VALUE, nil
default:
if first.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else {
return value.NULL_VALUE, nil
}
}
}
/*
This method returns an object value. The input of types
missing, null and object return themselves. For all other
values, return an _EMPTY_OBJECT value.
*/
func (this *ToObject) Apply(context Context, arg value.Value) (value.Value, error) {
switch arg.Type() {
case value.MISSING, value.NULL, value.OBJECT:
return arg, nil
}
return _EMPTY_OBJECT, nil
}
/*
Return the neagation of the input value, if the type of input is a number.
For missing return a missing value, and for all other input types return a
null.
*/
func (this *Neg) Apply(context Context, arg value.Value) (value.Value, error) {
if arg.Type() == value.NUMBER {
return value.NewValue(-arg.Actual().(float64)), nil
} else if arg.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else {
return value.NULL_VALUE, nil
}
}
/*
This method takes in an operand value and context and returns a value.
If the type of operand is missing then return it. Call MarshalJSON
to get the bytes, and then use Go's encoding/base64 package to
encode the bytes to string. Create a newValue using the string and
return it.
*/
func (this *Base64) Apply(context Context, operand value.Value) (value.Value, error) {
if operand.Type() == value.MISSING {
return operand, nil
}
bytes, _ := operand.MarshalJSON() // Ignore errors from BINARY values
str := base64.StdEncoding.EncodeToString(bytes)
return value.NewValue(str), nil
}
/*
It returns the argument itself if type of the input value is Null,
a value below this (N!QL order) or an Array. Otherwise convert the
argument to a valid Go type ang cast it to a slice of interface.
*/
func (this *ToArray) Apply(context Context, arg value.Value) (value.Value, error) {
if arg.Type() <= value.NULL {
return arg, nil
} else if arg.Type() == value.ARRAY {
return arg, nil
}
return value.NewValue([]interface{}{arg.Actual()}), nil
}
/*
This method takes in an argument value and returns a
lowercase string as value. If the input type is
missing return missing, and if it isnt string then
return null value. Use the ToLower method to
convert the string to lower case on a valid Go type
from the Actual method on the argument value. Return
this lower case string as Value.
*/
func (this *Lower) Apply(context Context, arg value.Value) (value.Value, error) {
if arg.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if arg.Type() != value.STRING {
return value.NULL_VALUE, nil
}
rv := strings.ToLower(arg.Actual().(string))
return value.NewValue(rv), nil
}
/*
This method returns true if he value is an array and contains at least one element.
This is done by checking the length of the array. If the type of input value
is missing then return a missing value, and for all other types return null.
*/
func (this *Exists) Apply(context Context, arg value.Value) (value.Value, error) {
if arg.Type() == value.ARRAY {
a := arg.Actual().([]interface{})
return value.NewValue(len(a) > 0), nil
} else if arg.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else {
return value.NULL_VALUE, nil
}
}
/*
Evaluates the Is Null comparison operation for expressions.
If the type of input argument is a null value, return true,
if missing return a missing value and by for all other types
return a false value.
*/
func (this *IsNull) Apply(context Context, arg value.Value) (value.Value, error) {
switch arg.Type() {
case value.NULL:
return value.TRUE_VALUE, nil
case value.MISSING:
return value.MISSING_VALUE, nil
default:
return value.FALSE_VALUE, nil
}
}
/*
It returns a string based on the input expr value. Values
missing, null and strings return themselves. False, true
(boolean) and numbers return their string representation.
This is done using the Sprint method defined in fmt for Go.
All other values map to null.
*/
func (this *ToString) Apply(context Context, arg value.Value) (value.Value, error) {
switch arg.Type() {
case value.MISSING, value.NULL, value.STRING:
return arg, nil
case value.BOOLEAN, value.NUMBER:
return value.NewValue(fmt.Sprint(arg.Actual())), nil
default:
return value.NULL_VALUE, nil
}
}
/*
This method returns the length of the input array using
the len method. If the input value is of type missing
return a missing value, and for all non array values
return null.
*/
func (this *ArrayLength) Apply(context Context, arg value.Value) (value.Value, error) {
if arg.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if arg.Type() != value.ARRAY {
return value.NULL_VALUE, nil
}
aa := arg.Actual().([]interface{})
return value.NewValue(float64(len(aa))), nil
}
/*
This method takes in an argument value and returns its length
as value. If the input type is missing return missing, and if
it isnt string then return null value. Use the len method to
return the length of the input string. Convert it into valid
N1QL value and return.
*/
func (this *Length) Apply(context Context, arg value.Value) (value.Value, error) {
if arg.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if arg.Type() != value.STRING {
return value.NULL_VALUE, nil
}
rv := len(arg.Actual().(string))
return value.NewValue(float64(rv)), nil
}
/*
This method returns the length of the object. If the type of
input is missing then return a missing value, and if not an
object return a null value. Convert it to a valid Go type.
Cast it to a map from string to interface and return its
length by using the len function by casting it to float64.
*/
func (this *ObjectLength) Apply(context Context, arg value.Value) (value.Value, error) {
if arg.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if arg.Type() != value.OBJECT {
return value.NULL_VALUE, nil
}
oa := arg.Actual().(map[string]interface{})
return value.NewValue(float64(len(oa))), nil
}
func (this *Sum) CumulateInitial(item, cumulative value.Value, context Context) (value.Value, error) {
item, e := this.Operand().Evaluate(item, context)
if e != nil {
return nil, e
}
if item.Type() != value.NUMBER {
return cumulative, nil
}
return this.cumulatePart(item, cumulative, context)
}
/*
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
}
}
/*
Aggregates input data by evaluating operands.For all
values other than Number, return the input value itself.
Call setAdd to compute the intermediate aggregate value
and return it.
*/
func (this *AvgDistinct) CumulateInitial(item, cumulative value.Value, context Context) (value.Value, error) {
item, e := this.Operand().Evaluate(item, context)
if e != nil {
return nil, e
}
if item.Type() != value.NUMBER {
return cumulative, nil
}
return setAdd(item, cumulative)
}
/*
This method sorts the input array value, in N1QL collation
order. It uses the Sort method in the sort package. If the
input value is of type missing return a missing value, and
for all non array values return null.
*/
func (this *ArraySort) Apply(context Context, arg value.Value) (value.Value, error) {
if arg.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if arg.Type() != value.ARRAY {
return value.NULL_VALUE, nil
}
cv := arg.Copy()
sorter := value.NewSorter(cv)
sort.Sort(sorter)
return cv, nil
}
/*
Aggregates input data by evaluating operands. For missing
item values, return the input value itself. Call
cumulatePart to compute the intermediate aggregate value
and return it.
*/
func (this *ArrayAgg) CumulateInitial(item, cumulative value.Value, context Context) (value.Value, error) {
item, e := this.Operand().Evaluate(item, context)
if e != nil {
return nil, e
}
if item.Type() <= value.MISSING {
return cumulative, nil
}
return this.cumulatePart(value.NewValue([]interface{}{item}), cumulative, context)
}
/*
Aggregates input data by evaluating operands. For all
values other than Number, return the input value itself. Call
cumulatePart to compute the intermediate aggregate value
and return it.
*/
func (this *Avg) CumulateInitial(item, cumulative value.Value, context Context) (value.Value, error) {
item, e := this.Operand().Evaluate(item, context)
if e != nil {
return nil, e
}
if item.Type() != value.NUMBER {
return cumulative, nil
}
part := value.NewValue(map[string]interface{}{"sum": item.Actual(), "count": 1})
return this.cumulatePart(part, cumulative, context)
}
/*
This method takes in two values and returns a value that
corresponds to the first position of the regular expression
pattern (already set or populated using the second value)
in the first string value, or -1 if it isnt found. If the
input type is missing return missing, and if it isnt
string then return null value. Use the FindStringIndex
method in the regexp package to return a two-element slice
of integers defining the location of the leftmost match in
the string of the regular expression as per the Go Docs. Return
the first element of this slice as a value. If a FindStringIndex
returns nil, then the regexp pattern isnt found. Hence return -1.
*/
func (this *RegexpPosition) 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.STRING || second.Type() != value.STRING {
return value.NULL_VALUE, nil
}
f := first.Actual().(string)
s := second.Actual().(string)
re := this.re
if re == nil {
var err error
re, err = regexp.Compile(s)
if err != nil {
return nil, err
}
}
loc := re.FindStringIndex(f)
if loc == nil {
return value.NewValue(-1.0), nil
}
return value.NewValue(float64(loc[0])), nil
}
/*
Aggregates input data by evaluating operands. For missing and
null values return the input value itself. Call cumulatePart
to compute the intermediate aggregate value and return it.
*/
func (this *Count) CumulateInitial(item, cumulative value.Value, context Context) (value.Value, error) {
if this.Operand() != nil {
item, e := this.Operand().Evaluate(item, context)
if e != nil {
return nil, e
}
if item.Type() <= value.NULL {
return cumulative, nil
}
}
return this.cumulatePart(value.ONE_VALUE, cumulative, context)
}
/*
This method returns the input array with distinct elements.
If the input value is of type missing return a missing
value, and for all non array values return null. Create
a new set and add all distinct values to the set. Return it.
*/
func (this *ArrayDistinct) Apply(context Context, arg value.Value) (value.Value, error) {
if arg.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if arg.Type() != value.ARRAY {
return value.NULL_VALUE, nil
}
aa := arg.Actual().([]interface{})
set := value.NewSet(len(aa))
for _, a := range aa {
set.Add(value.NewValue(a))
}
return value.NewValue(set.Actuals()), nil
}
/*
This method evaluates the input value and returns the length
based on its type. If the input argument is a missing then
return a missing value. Convert it to a valid Go type. If
it is a string slice of interfaces or object then return
its length cast as a number float64. By default return a
null value.
*/
func (this *PolyLength) Apply(context Context, arg value.Value) (value.Value, error) {
if arg.Type() == value.MISSING {
return value.MISSING_VALUE, nil
}
switch oa := arg.Actual().(type) {
case string:
return value.NewValue(float64(len(oa))), nil
case []interface{}:
return value.NewValue(float64(len(oa))), nil
case map[string]interface{}:
return value.NewValue(float64(len(oa))), nil
default:
return value.NULL_VALUE, nil
}
}
/*
This method evaluates the less than equal to condition and
returns a value representing if the two operands satisfy the
condition 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 the Collate
method and check if it is less than equal to 0 for the
two values. If it is, then return true.
*/
func (this *LE) 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.Collate(second) <= 0), nil
}
/*
This method ranges through the array and returns the first
non null value in the array. It returns missing if input
type is missing and null for non array values.
*/
func (this *ArrayIfNull) Apply(context Context, arg value.Value) (value.Value, error) {
if arg.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if arg.Type() != value.ARRAY {
return value.NULL_VALUE, nil
}
aa := arg.Actual().([]interface{})
for _, a := range aa {
v := value.NewValue(a)
if v.Type() > value.NULL {
return v, nil
}
}
return value.NULL_VALUE, nil
}
/*
This method reverses the input array value and returns it.
If the input value is of type missing return a missing
value, and for all non array values return null. Range
through the array and add it to a new slice in reverse.
*/
func (this *ArrayReverse) Apply(context Context, arg value.Value) (value.Value, error) {
if arg.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if arg.Type() != value.ARRAY {
return value.NULL_VALUE, nil
}
aa := arg.Actual().([]interface{})
n := len(aa)
ra := make([]interface{}, n)
n--
for i, _ := range aa {
ra[i] = aa[n-i]
}
return value.NewValue(ra), nil
}
/*
Evaluate the difference for the first and second input
values to return a value. If both values are numbers, calculate
the difference and return it. If either of the expressions are
missing then return a missing value. For all other cases return
a null value.
*/
func (this *Sub) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.NUMBER && second.Type() == value.NUMBER {
diff := first.Actual().(float64) - second.Actual().(float64)
return value.NewValue(diff), nil
} else if first.Type() == value.MISSING || second.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else {
return value.NULL_VALUE, nil
}
}
/*
This method takes in two values and returns new value that returns a boolean
value that depicts if the second value is contained within the first. If
either of the input values are missing, return a missing value, and if they
arent strings then return a null value. Use the Contains method from the
string package to return a boolean value that is true if substring (second)
is within the string(first).
*/
func (this *Contains) 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.STRING || second.Type() != value.STRING {
return value.NULL_VALUE, nil
}
rv := strings.Contains(first.Actual().(string), second.Actual().(string))
return value.NewValue(rv), nil
}
/*
This method takes in two values and returns a value that
corresponds to the second expressions position in the
first. If the input type is missing return missing, and
if it isnt string then return null value. Use the Index
method defined by the strings package to calculate the
offset position of the second string. Return that value.
*/
func (this *Position) 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.STRING || second.Type() != value.STRING {
return value.NULL_VALUE, nil
}
rv := strings.Index(first.Actual().(string), second.Actual().(string))
return value.NewValue(float64(rv)), nil
}