/* 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 } } }
/* 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 }
/* 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 } }
/* 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 }
/* 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 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 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 } }
/* 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 } }
func (this *ParentScan) RunOnce(context *Context, parent value.Value) { this.once.Do(func() { defer context.Recover() // Recover from any panic defer close(this.itemChannel) // Broadcast that I have stopped defer this.notify() // Notify that I have stopped // Shallow copy of the parent includes // correlated and annotated aspects this.sendItem(parent.Copy().(value.AnnotatedValue)) }) }
/* Aggregate input partial values into cumulative result value. If partial result is null return the current cumulative value, and if the cumulative result is null, return the partial value. For non null partial and cumulative values, call Collate and return the smaller value depending on the N1QL collation order. */ func (this *Min) cumulatePart(part, cumulative value.Value, context Context) (value.Value, error) { if part == value.NULL_VALUE { return cumulative, nil } else if cumulative == value.NULL_VALUE { return part, nil } else if part.Collate(cumulative) < 0 { return part, nil } else { return cumulative, 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) }
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) }
/* 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 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 } }
func (this *Order) Less(i, j int) bool { v1 := this.values[i] v2 := this.values[j] var ev1, ev2 value.Value var c int var e error for i, term := range this.plan.Terms() { s := strconv.Itoa(i) sv1 := v1.GetAttachment(s) switch sv1 := sv1.(type) { case value.Value: ev1 = sv1 default: ev1, e = term.Expression().Evaluate(v1, this.context) if e != nil { this.context.Error(errors.NewError(e, "Error evaluating ORDER BY.")) return false } v1.SetAttachment(s, ev1) } sv2 := v2.GetAttachment(s) switch sv2 := sv2.(type) { case value.Value: ev2 = sv2 default: ev2, e = term.Expression().Evaluate(v2, this.context) if e != nil { this.context.Error(errors.NewError(e, "Error evaluating ORDER BY.")) return false } v2.SetAttachment(s, ev2) } c = ev1.Collate(ev2) if c == 0 { continue } else if term.Descending() { return c > 0 } else { return c < 0 } } return false }
/* 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 } }
/* 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) }
/* 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) } }
/* 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) }
/* 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) } }
/* 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) }
/* 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 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 }
/* 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 slive using the input args depending on the number of args. The form source-expr [ start : end ] is called array slicing. It returns a new array containing a subset of the source, containing the elements from position start to end-1. The element at start is included, while the element at end is not. If end is omitted, all elements from start to the end of the source array are included. The source is the first argument. If it is missing return a missing value. The first argument represents start. If missing return missing. If there are more than 2 arguments, then an end is specified. Check its type, and if missing return missing value. Since start and end represent indices, make sure they are integer values and if not return null value. Call Slice or Slice tail on the source (depending on whether end is specified) to return the specified slice. */ func (this *Slice) Apply(context Context, args ...value.Value) (rv value.Value, re error) { source := args[0] if source.Type() == value.MISSING { return value.MISSING_VALUE, nil } start := args[1] if start.Type() == value.MISSING { return value.MISSING_VALUE, nil } ev := -1 var end value.Value if len(args) >= 3 { end = args[2] if end.Type() == value.MISSING { return value.MISSING_VALUE, nil } ea, ok := end.Actual().(float64) if !ok || ea != math.Trunc(ea) { return value.NULL_VALUE, nil } ev = int(ea) } sa, ok := start.Actual().(float64) if !ok || sa != math.Trunc(sa) { return value.NULL_VALUE, nil } if source.Type() != value.ARRAY { return value.NULL_VALUE, nil } if end != nil { rv, _ = source.Slice(int(sa), ev) } else { rv, _ = source.SliceTail(int(sa)) } return }
/* 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 }
/* If the input argument type is a missing, null or boolean value, it returns itself. Check to see the Go type of the input. If it is float64, then use the isNaN(returns if input is not a number) method defined in the math package and make sure that it returns false and the number is not 0, return true. If type is string, slice of interface or map which are are not empty, return true. All other input types return NULLs. */ func (this *ToBoolean) Apply(context Context, arg value.Value) (value.Value, error) { switch arg.Type() { case value.MISSING, value.NULL, value.BOOLEAN: return arg, nil default: switch a := arg.Actual().(type) { case float64: return value.NewValue(!math.IsNaN(a) && a != 0), nil case string: return value.NewValue(len(a) > 0), nil case []interface{}: return value.NewValue(len(a) > 0), nil case map[string]interface{}: return value.NewValue(len(a) > 0), nil default: return value.NULL_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 }
/* Compute the Final. Compute the sum and the count. If these arent numbers throw an error. Compute the avg as sum/count. Check for divide by zero, and return a NULL value if true. */ func (this *Avg) ComputeFinal(cumulative value.Value, context Context) (value.Value, error) { if cumulative == value.NULL_VALUE { return cumulative, nil } sum, _ := cumulative.Field("sum") count, _ := cumulative.Field("count") if sum.Type() != value.NUMBER || count.Type() != value.NUMBER { return nil, fmt.Errorf("Missing or invalid sum or count in AVG: %v, %v.", sum.Actual(), count.Actual()) } if count.Actual().(float64) > 0.0 { return value.NewValue(sum.Actual().(float64) / count.Actual().(float64)), nil } else { return value.NULL_VALUE, 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 }