/* 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 evaluates the between comparison operation and returns a value representing if item value is in between low and high. If any of the input operands are missing, return missing, and if null return null. For all other types, check if the item is greater in terms of the N1QL collation order, than the low value and smaller than high value, and return true. If not return false. */ func (this *Between) Apply(context Context, item, low, high value.Value) (value.Value, error) { if item.Type() == value.MISSING || low.Type() == value.MISSING || high.Type() == value.MISSING { return value.MISSING_VALUE, nil } else if item.Type() == value.NULL || low.Type() == value.NULL || high.Type() == value.NULL { return value.NULL_VALUE, nil } return value.NewValue(item.Collate(low) >= 0 && item.Collate(high) <= 0), nil }
/* 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 } }
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 }