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())
}
}
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())
}
}
/*
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 := this.terms[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.NewEvaluationError(e, "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.NewEvaluationError(e, "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
}
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())
}
}
