sql: fix and enhance expression normalization.

This patch is needed so that the expressions in the Sqllogictest do
not cause the server to panic.

Summary:

- Bug fixes:

  - an invalid cast was attempted for some expressions; is now fixed.
  - NULL caused invalid transformations, NULL is now normalized on a
    fast path.
  - transformations that rebalance arithmetic across a comparison now
    first check that the proposed replacement arithmetic expression
    has a valid overload w.r.t typing.

- Improvements: more simplifications.

sql/parser/col_types.go

@@ -19,6 +19,8 @@ package parser
 import (
 	"bytes"
 	"fmt"
+
+	"github.com/pkg/errors"
 )
 
 // ColumnType represents a type in a column definition.
@@ -247,3 +249,30 @@ func (node *TimestampTZColType) String() string { return AsString(node) }
 func (node *IntervalColType) String() string    { return AsString(node) }
 func (node *StringColType) String() string      { return AsString(node) }
 func (node *BytesColType) String() string       { return AsString(node) }
+
+// DatumTypeToColumnType produces a SQL column type equivalent to the
+// given Datum type. Used to generate CastExpr nodes during
+// normalization.
+func DatumTypeToColumnType(d Datum) (ColumnType, error) {
+	switch d.(type) {
+	case *DInt:
+		return &IntColType{"INT", 0}, nil
+	case *DFloat:
+		return &FloatColType{"FLOAT", 0}, nil
+	case *DDecimal:
+		return &DecimalColType{"DECIMAL", 0, 0}, nil
+	case *DTimestamp:
+		return &TimestampColType{}, nil
+	case *DTimestampTZ:
+		return &TimestampTZColType{}, nil
+	case *DInterval:
+		return &IntervalColType{}, nil
+	case *DDate:
+		return &DateColType{}, nil
+	case *DString:
+		return &StringColType{"STRING", 0}, nil
+	case *DBytes:
+		return &BytesColType{"BYTES"}, nil
+	}
+	return nil, errors.Errorf("internal error: unknown Datum type %T", d)
+}

sql/parser/expr.go

@@ -456,6 +456,21 @@ type IfExpr struct {
 	typeAnnotation
 }
 
+// TypedTrueExpr returns the IfExpr's True expression as a TypedExpr.
+func (node *IfExpr) TypedTrueExpr() TypedExpr {
+	return node.True.(TypedExpr)
+}
+
+// TypedCondExpr returns the IfExpr's Cond expression as a TypedExpr.
+func (node *IfExpr) TypedCondExpr() TypedExpr {
+	return node.Cond.(TypedExpr)
+}
+
+// TypedElseExpr returns the IfExpr's Else expression as a TypedExpr.
+func (node *IfExpr) TypedElseExpr() TypedExpr {
+	return node.Else.(TypedExpr)
+}
+
 // Format implements the NodeFormatter interface.
 func (node *IfExpr) Format(buf *bytes.Buffer, f FmtFlags) {
 	buf.WriteString("IF(")
@@ -492,6 +507,11 @@ type CoalesceExpr struct {
 	typeAnnotation
 }
 
+// TypedExprAt returns the expression at the specified index as a TypedExpr.
+func (node *CoalesceExpr) TypedExprAt(idx int) TypedExpr {
+	return node.Exprs[idx].(TypedExpr)
+}
+
 // Format implements the NodeFormatter interface.
 func (node *CoalesceExpr) Format(buf *bytes.Buffer, f FmtFlags) {
 	buf.WriteString(node.Name)
@@ -967,6 +987,24 @@ func (node *BinaryExpr) memoizeFn() {
 	node.fn = fn
 }
 
+// newBinExprIfValidOverloads constructs a new BinaryExpr if and only
+// if the pair of arguments have a valid implementation.
+func newBinExprIfValidOverload(op BinaryOperator, left TypedExpr, right TypedExpr) *BinaryExpr {
+	leftRet, rightRet := left.ReturnType(), right.ReturnType()
+	fn, ok := BinOps[op].lookupImpl(leftRet, rightRet)
+	if ok {
+		expr := &BinaryExpr{
+			Operator: op,
+			Left:     left,
+			Right:    right,
+			fn:       fn,
+		}
+		expr.typ = fn.ReturnType
+		return expr
+	}
+	return nil
+}
+
 // Format implements the NodeFormatter interface.
 func (node *BinaryExpr) Format(buf *bytes.Buffer, f FmtFlags) {
 	binExprFmtWithParen(buf, f, node.Left, node.Operator.String(), node.Right)
@@ -1013,6 +1051,11 @@ func (node *UnaryExpr) Format(buf *bytes.Buffer, f FmtFlags) {
 	exprFmtWithParen(buf, f, node.Expr)
 }
 
+// TypedInnerExpr returns the UnaryExpr's inner expression as a TypedExpr.
+func (node *UnaryExpr) TypedInnerExpr() TypedExpr {
+	return node.Expr.(TypedExpr)
+}
+
 // FuncExpr represents a function call.
 type FuncExpr struct {
 	Name  *QualifiedName