Method normalize

pkg/sql/sem/tree/normalize.go:589–645

(v *NormalizeVisitor)

}

func (expr *RangeCond) normalize(v *NormalizeVisitor) TypedExpr {
	leftFrom, from := expr.TypedLeftFrom(), expr.TypedFrom()
	leftTo, to := expr.TypedLeftTo(), expr.TypedTo()
	// The visitor hasn't walked down into leftTo; do it now.
	if leftTo, v.err = v.ctx.NormalizeExpr(leftTo); v.err != nil {
		return expr
	}

	if (leftFrom == DNull || from == DNull) && (leftTo == DNull || to == DNull) {
		return DNull
	}

	leftCmp := GE
	rightCmp := LE
	if expr.Not {
		leftCmp = LT
		rightCmp = GT
	}

	// "a BETWEEN b AND c" -> "a >= b AND a <= c"
	// "a NOT BETWEEN b AND c" -> "a < b OR a > c"
	transform := func(from, to TypedExpr) TypedExpr {
		var newLeft, newRight TypedExpr
		if from == DNull {
			newLeft = DNull
		} else {
			newLeft = NewTypedComparisonExpr(leftCmp, leftFrom, from).normalize(v)
			if v.err != nil {
				return expr
			}
		}
		if to == DNull {
			newRight = DNull
		} else {
			newRight = NewTypedComparisonExpr(rightCmp, leftTo, to).normalize(v)
			if v.err != nil {
				return expr
			}
		}
		if expr.Not {
			return NewTypedOrExpr(newLeft, newRight).normalize(v)
		}
		return NewTypedAndExpr(newLeft, newRight).normalize(v)
	}

	out := transform(from, to)
	if expr.Symmetric {
		if expr.Not {
			// "a NOT BETWEEN SYMMETRIC b AND c" -> "(a < b OR a > c) AND (a < c OR a > b)"
			out = NewTypedAndExpr(out, transform(to, from)).normalize(v)
		} else {
			// "a BETWEEN SYMMETRIC b AND c" -> "(a >= b AND a <= c) OR (a >= c OR a <= b)"
			out = NewTypedOrExpr(out, transform(to, from)).normalize(v)
		}
	}
	return out
}