/*
This method removes all the occurences of the second value from the
first array value.
*/
func (this *ArrayRemove) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.MISSING {
return first, nil
}
if first.Type() != value.ARRAY {
return value.NULL_VALUE, nil
}
if second.Type() <= value.NULL {
return first, nil
}
fa := first.Actual().([]interface{})
if len(fa) == 0 {
return first, nil
}
ra := make([]interface{}, 0, len(fa))
for _, f := range fa {
if !second.Equals(value.NewValue(f)).Truth() {
ra = append(ra, f)
}
}
return value.NewValue(ra), nil
}
/*
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
}
/*
Perform either case-sensitive or case-insensitive field lookup.
*/
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 takes in an object, a name and a value
and returns a new object that contains the name /
attribute pair. If the type of input is missing
then return a missing value, and if not an object
return a null value.
If the key is found, an error is thrown
*/
func (this *ObjectAdd) Apply(context Context, first, second, third value.Value) (value.Value, error) {
// First must be an object, or we're out
if first.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if first.Type() != value.OBJECT {
return value.NULL_VALUE, nil
}
// second must be a non empty string
if second.Type() != value.STRING || second.Actual().(string) == "" {
return first, nil
}
field := second.Actual().(string)
// we don't overwrite
_, exists := first.Field(field)
if exists {
return value.NULL_VALUE, nil
}
// SetField will remove if the attribute is missing, but we don't
// overwrite anyway, so we might just skip now
if third.Type() != value.MISSING {
rv := first.CopyForUpdate()
rv.SetField(field, third)
return rv, nil
}
return first, 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
}
}
func (this *preparedCache) get(name value.Value) *Prepared {
if name.Type() != value.STRING || !name.Truth() {
return nil
}
this.RLock()
rv := this.prepareds[name.Actual().(string)]
this.RUnlock()
return rv
}
/*
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 testArrayInsert_eval(e1, e2, e3 Expression, er value.Value, t *testing.T) {
eai := NewArrayInsert(e1, e2, e3)
rv, err := eai.Evaluate(nil, nil)
if err != nil {
t.Errorf("received error %v", err)
}
if er.Collate(rv) != 0 {
t.Errorf("mismatch received %v expected %v", rv.Actual(), er.Actual())
}
}
/*
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
}
/*
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
}
}
/*
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
}
func testObjectRemove(e1, e2 Expression, er value.Value, t *testing.T) {
eop := NewObjectRemove(e1, e2)
rv, err := eop.Evaluate(nil, nil)
if err != nil {
t.Errorf("received error %v", err)
}
if er.Collate(rv) != 0 {
t.Errorf("mismatch received %v expected %v", rv.Actual(), er.Actual())
}
}
/*
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 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
}
/*
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 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 evaluates the array append function. If either
of the input argument types are missing, or not an array return
a missing and null value respectively. Use the append method
to append the second expression to the first expression. Return
the new array.
*/
func (this *ArrayAppend) 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
}
f := first.Actual().([]interface{})
ra := append(f, second)
return value.NewValue(ra), 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
} else if arg.Type() == value.BINARY {
return value.NULL_VALUE, nil
}
return value.NewValue([]interface{}{arg.Actual()}), nil
}
/*
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)
}
func (this *Base64Decode) Apply(context Context, operand value.Value) (value.Value, error) {
if operand.Type() == value.MISSING {
return operand, nil
} else if operand.Type() != value.STRING {
return value.NULL_VALUE, nil
}
str, err := base64.StdEncoding.DecodeString(operand.Actual().(string))
if err != nil {
return value.NULL_VALUE, nil
} else {
return value.NewValue(str), nil
}
}
/*
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
}
/*
Aggregate input partial values into cumulative result number value.
If the partial and current cumulative result are both float64
numbers, add them and return.
*/
func (this *Count) cumulatePart(part, cumulative value.Value, context Context) (value.Value, error) {
actual := part.Actual()
switch actual := actual.(type) {
case float64:
count := cumulative.Actual()
switch count := count.(type) {
case float64:
return value.NewValue(count + actual), nil
default:
return nil, fmt.Errorf("Invalid COUNT %v of type %T.", count, count)
}
default:
return nil, fmt.Errorf("Invalid partial COUNT %v of type %T.", actual, actual)
}
}
/*
This method returns a string value that repeats the first value
second number of times. If either of the input values are
missing, return a missing value, and if the first isnt a string
and the second isnt a number then return a null value. Check if the
number n is less than 0 and if it isnt an integer, then return null
value. Call the Repeat method from the strings package with the
string and number and return that stringvalue.
*/
func (this *Repeat) 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.NUMBER {
return value.NULL_VALUE, nil
}
nf := second.Actual().(float64)
if nf < 0.0 || nf != math.Trunc(nf) {
return value.NULL_VALUE, nil
}
rv := strings.Repeat(first.Actual().(string), int(nf))
return value.NewValue(rv), nil
}
/*
This method prepends the first value to the second value, by
reversing the input to the append method. If either
of the input argument types are missing, or not an array return
a missing and null value respectively.
*/
func (this *ArrayPrepend) Apply(context Context, first, second value.Value) (value.Value, error) {
if second.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if second.Type() != value.ARRAY {
return value.NULL_VALUE, nil
} else if first.Type() == value.MISSING {
return second, nil
}
s := second.Actual().([]interface{})
ra := make([]interface{}, 1, len(s)+1)
ra[0] = first
ra = append(ra, s...)
return value.NewValue(ra), nil
}
func testObjectAdd(e1, e2, e3 Expression, er value.Value, fail bool, t *testing.T) {
eop := NewObjectAdd(e1, e2, e3)
rv, err := eop.Evaluate(nil, nil)
if err != nil {
if fail && rv.Actual() == nil {
return
}
t.Errorf("received error %v", err)
} else if fail {
t.Errorf("error expected, received success")
}
if er.Collate(rv) != 0 {
t.Errorf("mismatch received %v expected %v", rv.Actual(), er.Actual())
}
}
/*
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)).Truth() {
return value.TRUE_VALUE, nil
}
}
return value.FALSE_VALUE, nil
}
func (this *preparedCache) get(name value.Value, track bool) *Prepared {
if name.Type() != value.STRING || !name.Truth() {
return nil
}
this.RLock()
defer this.RUnlock()
rv := this.prepareds[name.Actual().(string)]
if rv != nil {
if track {
atomic.AddInt32(&rv.uses, 1)
rv.lastUse = time.Now()
}
return rv.prepared
}
return 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)).Truth() {
return value.NewValue(float64(i)), nil
}
}
return value.NewValue(float64(-1)), 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
}
/*
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
}