stream: clone stream before execution

internal/expr/comparison.go

@@ -59,6 +59,10 @@ func (op *cmpOp) compare(l, r types.Value) (bool, error) {
 	}
 }
 
+func (op *cmpOp) Clone() Expr {
+	return &cmpOp{op.simpleOperator.Clone()}
+}
+
 // Eq creates an expression that returns true if a equals b.
 func Eq(a, b Expr) Expr {
 	return newCmpOp(a, b, scanner.EQ)
@@ -102,6 +106,13 @@ func Between(a Expr) func(x, b Expr) Expr {
 	}
 }
 
+func (op *BetweenOperator) Clone() Expr {
+	return &BetweenOperator{
+		op.simpleOperator.Clone(),
+		Clone(op.X),
+	}
+}
+
 func (op *BetweenOperator) Eval(env *environment.Environment) (types.Value, error) {
 	x, err := op.X.Eval(env)
 	if err != nil {
@@ -152,15 +163,23 @@ func In(a Expr, b Expr) Expr {
 	return &InOperator{a, b, scanner.IN}
 }
 
-func (op InOperator) Precedence() int {
+func (op *InOperator) Clone() Expr {
+	return &InOperator{
+		Clone(op.a),
+		Clone(op.b),
+		op.op,
+	}
+}
+
+func (op *InOperator) Precedence() int {
 	return op.op.Precedence()
 }
 
-func (op InOperator) LeftHand() Expr {
+func (op *InOperator) LeftHand() Expr {
 	return op.a
 }
 
-func (op InOperator) RightHand() Expr {
+func (op *InOperator) RightHand() Expr {
 	return op.b
 }
 
@@ -242,12 +261,18 @@ func (op *InOperator) validateRightExpression(b Expr) (LiteralExprList, error) {
 }
 
 type NotInOperator struct {
-	InOperator
+	*InOperator
 }
 
 // NotIn creates an expression that evaluates to the result of a NOT IN b.
 func NotIn(a Expr, b Expr) Expr {
-	return &NotInOperator{InOperator{a, b, scanner.NIN}}
+	return &NotInOperator{&InOperator{a, b, scanner.NIN}}
+}
+
+func (op *NotInOperator) Clone() Expr {
+	return &NotInOperator{
+		op.InOperator.Clone().(*InOperator),
+	}
 }
 
 func (op *NotInOperator) Eval(env *environment.Environment) (types.Value, error) {
@@ -267,6 +292,12 @@ func Is(a, b Expr) Expr {
 	return &IsOperator{&simpleOperator{a, b, scanner.IN}}
 }
 
+func (op *IsOperator) Clone() Expr {
+	return &IsOperator{
+		op.simpleOperator.Clone(),
+	}
+}
+
 func (op *IsOperator) Eval(env *environment.Environment) (types.Value, error) {
 	return op.simpleOperator.eval(env, func(a, b types.Value) (types.Value, error) {
 		ok, err := a.EQ(b)
@@ -290,6 +321,12 @@ func IsNot(a, b Expr) Expr {
 	return &IsNotOperator{&simpleOperator{a, b, scanner.ISN}}
 }
 
+func (op *IsNotOperator) Clone() Expr {
+	return &IsNotOperator{
+		op.simpleOperator.Clone(),
+	}
+}
+
 func (op *IsNotOperator) Eval(env *environment.Environment) (types.Value, error) {
 	return op.simpleOperator.eval(env, func(a, b types.Value) (types.Value, error) {
 		eq, err := a.EQ(b)