avoid heap allocs in transform.Inspect and transform.InspectExpr

optgen/cmd/support/agg_gen.go

@@ -85,7 +85,7 @@ func (g *AggGen) genAggConstructor(define AggDef) {
 	fmt.Fprintf(g.w, "func New%s(e sql.Expression) *%s {\n", define.Name, define.Name)
 	fmt.Fprintf(g.w, "    return &%s{\n", define.Name)
 	fmt.Fprintf(g.w, "        unaryAggBase{\n")
-	fmt.Fprintf(g.w, "            UnaryExpression: expression.UnaryExpression{Child: e},\n")
+	fmt.Fprintf(g.w, "            Child: e,\n")
 	fmt.Fprintf(g.w, "            functionName: \"%s\",\n", define.Name)
 	fmt.Fprintf(g.w, "            description: \"%s\",\n", define.Desc)
 	fmt.Fprintf(g.w, "        },\n")

optgen/cmd/support/agg_gen_test.go

@@ -41,7 +41,7 @@ func TestAggGen(t *testing.T) {
         func NewTest(e sql.Expression) *Test {
             return &Test{
                 unaryAggBase{
-                    UnaryExpression: expression.UnaryExpression{Child: e},
+                    Child: e,
                     functionName: "Test",
                     description: "Test description",
                 },

sql/analyzer/replace_sort.go

@@ -373,7 +373,7 @@ func replaceAgg(ctx *sql.Context, a *Analyzer, node sql.Node, scope *plan.Scope,
 		var sf sql.SortField
 		switch agg := gb.SelectDeps[0].(type) {
 		case *aggregation.Max:
-			gf, ok := agg.UnaryExpression.Child.(*expression.GetField)
+			gf, ok := agg.Child.(*expression.GetField)
 			if !ok {
 				return n, transform.SameTree, nil
 			}
@@ -382,7 +382,7 @@ func replaceAgg(ctx *sql.Context, a *Analyzer, node sql.Node, scope *plan.Scope,
 				Order:  sql.Descending,
 			}
 		case *aggregation.Min:
-			gf, ok := agg.UnaryExpression.Child.(*expression.GetField)
+			gf, ok := agg.Child.(*expression.GetField)
 			if !ok {
 				return n, transform.SameTree, nil
 			}

sql/analyzer/symbol_resolution.go

@@ -178,12 +178,22 @@ func findSubqueryExpr(n sql.Node) *plan.Subquery {
 // hasMatchAgainstExpr searches for an *expression.MatchAgainst within the node's expressions
 func hasMatchAgainstExpr(node sql.Node) bool {
 	var foundMatchAgainstExpr bool
-	transform.InspectExpressions(node, func(expr sql.Expression) bool {
-		_, isMatchAgainstExpr := expr.(*expression.MatchAgainst)
-		if isMatchAgainstExpr {
-			foundMatchAgainstExpr = true
+	transform.Inspect(node, func(n sql.Node) (cont bool) {
+		if ne, ok := n.(sql.Expressioner); ok {
+			for _, expr := range ne.Expressions() {
+				stop := transform.InspectExpr(expr, func(e sql.Expression) (stop bool) {
+					if _, isMatchAgainst := e.(*expression.MatchAgainst); isMatchAgainst {
+						foundMatchAgainstExpr = true
+						return true
+					}
+					return false
+				})
+				if stop {
+					return false
+				}
+			}
 		}
-		return !foundMatchAgainstExpr
+		return true
 	})
 	return foundMatchAgainstExpr
 }

sql/expression/alias.go

@@ -80,7 +80,7 @@ var _ sql.CollationCoercible = (*AliasReference)(nil)
 
 // Alias is a node that gives a name to an expression.
 type Alias struct {
-	UnaryExpression
+	UnaryExpressionStub
 	name           string
 	unreferencable bool
 	id             sql.ColumnId
@@ -92,7 +92,7 @@ var _ sql.CollationCoercible = (*Alias)(nil)
 
 // NewAlias returns a new Alias node.
 func NewAlias(name string, expr sql.Expression) *Alias {
-	return &Alias{UnaryExpression{expr}, name, false, 0}
+	return &Alias{UnaryExpressionStub{expr}, name, false, 0}
 }
 
 // AsUnreferencable marks the alias outside of scope referencing

sql/expression/arithmetic.go

@@ -681,15 +681,15 @@ func mult(lval, rval interface{}) (interface{}, error) {
 
 // UnaryMinus is an unary minus operator.
 type UnaryMinus struct {
-	UnaryExpression
+	UnaryExpressionStub
 }
 
 var _ sql.Expression = (*UnaryMinus)(nil)
 var _ sql.CollationCoercible = (*UnaryMinus)(nil)
 
 // NewUnaryMinus creates a new UnaryMinus expression node.
 func NewUnaryMinus(child sql.Expression) *UnaryMinus {
-	return &UnaryMinus{UnaryExpression{Child: child}}
+	return &UnaryMinus{UnaryExpressionStub{Child: child}}
 }
 
 // Eval implements the sql.Expression interface.

sql/expression/auto_increment.go

@@ -31,7 +31,7 @@ var (
 
 // AutoIncrement implements AUTO_INCREMENT
 type AutoIncrement struct {
-	UnaryExpression
+	UnaryExpressionStub
 	autoTbl sql.AutoIncrementTable
 	autoCol *sql.Column
 }
@@ -58,7 +58,7 @@ func NewAutoIncrement(ctx *sql.Context, table sql.Table, given sql.Expression) (
 	}
 
 	return &AutoIncrement{
-		UnaryExpression{Child: given},
+		UnaryExpressionStub{Child: given},
 		autoTbl,
 		autoCol,
 	}, nil
@@ -72,7 +72,7 @@ func NewAutoIncrementForColumn(ctx *sql.Context, table sql.Table, autoCol *sql.C
 	}
 
 	return &AutoIncrement{
-		UnaryExpression{Child: given},
+		UnaryExpressionStub{Child: given},
 		autoTbl,
 		autoCol,
 	}, nil
@@ -159,7 +159,7 @@ func (i *AutoIncrement) WithChildren(children ...sql.Expression) (sql.Expression
 		return nil, sql.ErrInvalidChildrenNumber.New(i, len(children), 1)
 	}
 	return &AutoIncrement{
-		UnaryExpression{Child: children[0]},
+		UnaryExpressionStub{Child: children[0]},
 		i.autoTbl,
 		i.autoCol,
 	}, nil

sql/expression/auto_uuid.go

@@ -26,7 +26,7 @@ import (
 // AutoUuid is an expression that captures an automatically generated UUID value and stores it in the session for
 // later retrieval. AutoUuid is intended to only be used directly on top of a UUID function.
 type AutoUuid struct {
-	UnaryExpression
+	UnaryExpressionStub
 	uuidCol   *sql.Column
 	foundUuid bool
 }
@@ -38,8 +38,8 @@ var _ sql.CollationCoercible = (*AutoUuid)(nil)
 // because of package import cycles, we can't enforce that directly here.
 func NewAutoUuid(_ *sql.Context, col *sql.Column, child sql.Expression) *AutoUuid {
 	return &AutoUuid{
-		UnaryExpression: UnaryExpression{Child: child},
-		uuidCol:         col,
+		UnaryExpressionStub: UnaryExpressionStub{Child: child},
+		uuidCol:             col,
 	}
 }
 
@@ -94,9 +94,9 @@ func (au *AutoUuid) WithChildren(children ...sql.Expression) (sql.Expression, er
 		return nil, sql.ErrInvalidChildrenNumber.New(au, len(children), 1)
 	}
 	return &AutoUuid{
-		UnaryExpression: UnaryExpression{Child: children[0]},
-		uuidCol:         au.uuidCol,
-		foundUuid:       au.foundUuid,
+		UnaryExpressionStub: UnaryExpressionStub{Child: children[0]},
+		uuidCol:             au.uuidCol,
+		foundUuid:           au.foundUuid,
 	}, nil
 }
 

sql/expression/binary.go

@@ -28,14 +28,14 @@ import (
 //
 // cc: https://dev.mysql.com/doc/refman/8.0/en/cast-functions.html#operator_binary
 type Binary struct {
-	UnaryExpression
+	UnaryExpressionStub
 }
 
 var _ sql.Expression = (*Binary)(nil)
 var _ sql.CollationCoercible = (*Binary)(nil)
 
 func NewBinary(e sql.Expression) sql.Expression {
-	return &Binary{UnaryExpression{Child: e}}
+	return &Binary{UnaryExpressionStub{Child: e}}
 }
 
 func (b *Binary) String() string {

sql/expression/boolean.go

@@ -23,15 +23,15 @@ import (
 
 // Not is a node that negates an expression.
 type Not struct {
-	UnaryExpression
+	UnaryExpressionStub
 }
 
 var _ sql.Expression = (*Not)(nil)
 var _ sql.CollationCoercible = (*Not)(nil)
 
 // NewNot returns a new Not node.
 func NewNot(child sql.Expression) *Not {
-	return &Not{UnaryExpression{child}}
+	return &Not{UnaryExpressionStub{child}}
 }
 
 // Type implements the Expression interface.

sql/expression/common.go

@@ -32,39 +32,49 @@ func IsBinary(e sql.Expression) bool {
 	return len(e.Children()) == 2
 }
 
-// UnaryExpression is an expression that has only one child.
-type UnaryExpression struct {
+type UnaryExpression interface {
+	sql.Expression
+	UnaryChild() sql.Expression
+}
+
+// UnaryExpressionStub is an expression that has only one child.
+type UnaryExpressionStub struct {
 	Child sql.Expression
 }
 
+// UnaryChild implements the UnaryExpression interface.
+func (p *UnaryExpressionStub) UnaryChild() sql.Expression {
+	return p.Child
+}
+
 // Children implements the Expression interface.
-func (p *UnaryExpression) Children() []sql.Expression {
+func (p *UnaryExpressionStub) Children() []sql.Expression {
 	return []sql.Expression{p.Child}
 }
 
 // Resolved implements the Expression interface.
-func (p *UnaryExpression) Resolved() bool {
+func (p *UnaryExpressionStub) Resolved() bool {
 	return p.Child.Resolved()
 }
 
 // IsNullable returns whether the expression can be null.
-func (p *UnaryExpression) IsNullable() bool {
+func (p *UnaryExpressionStub) IsNullable() bool {
 	return p.Child.IsNullable()
 }
 
-// BinaryExpressionStub is an expression that has two children.
-type BinaryExpressionStub struct {
-	LeftChild  sql.Expression
-	RightChild sql.Expression
-}
-
 // BinaryExpression is an expression that has two children
 type BinaryExpression interface {
 	sql.Expression
 	Left() sql.Expression
 	Right() sql.Expression
 }
 
+// BinaryExpressionStub is an expression that has two children.
+type BinaryExpressionStub struct {
+	LeftChild  sql.Expression
+	RightChild sql.Expression
+}
+
 func (p *BinaryExpressionStub) Left() sql.Expression {
 	return p.LeftChild
 }

sql/expression/convert.go

@@ -64,7 +64,7 @@ const (
 
 // Convert represent a CAST(x AS T) or CONVERT(x, T) operation that casts x expression to type T.
 type Convert struct {
-	UnaryExpression
+	UnaryExpressionStub
 
 	// cachedDecimalType is the cached Decimal type for this convert expression. Because new Decimal types
 	// must be created with their specific scale and precision values, unlike other types, we cache the created
@@ -88,8 +88,8 @@ var _ sql.CollationCoercible = (*Convert)(nil)
 func NewConvert(expr sql.Expression, castToType string) *Convert {
 	disableRounding(expr)
 	return &Convert{
-		UnaryExpression: UnaryExpression{Child: expr},
-		castToType:      strings.ToLower(castToType),
+		UnaryExpressionStub: UnaryExpressionStub{Child: expr},
+		castToType:          strings.ToLower(castToType),
 	}
 }
 
@@ -99,10 +99,10 @@ func NewConvert(expr sql.Expression, castToType string) *Convert {
 func NewConvertWithLengthAndScale(expr sql.Expression, castToType string, typeLength, typeScale int) *Convert {
 	disableRounding(expr)
 	return &Convert{
-		UnaryExpression: UnaryExpression{Child: expr},
-		castToType:      strings.ToLower(castToType),
-		typeLength:      typeLength,
-		typeScale:       typeScale,
+		UnaryExpressionStub: UnaryExpressionStub{Child: expr},
+		castToType:          strings.ToLower(castToType),
+		typeLength:          typeLength,
+		typeScale:           typeScale,
 	}
 }
 

sql/expression/convertusing.go

@@ -23,7 +23,7 @@ import (
 
 // ConvertUsing represents a CONVERT(X USING T) operation that casts the expression X to the character set T.
 type ConvertUsing struct {
-	UnaryExpression
+	UnaryExpressionStub
 	TargetCharSet sql.CharacterSetID
 }
 
@@ -32,8 +32,8 @@ var _ sql.CollationCoercible = (*ConvertUsing)(nil)
 
 func NewConvertUsing(expr sql.Expression, targetCharSet sql.CharacterSetID) *ConvertUsing {
 	return &ConvertUsing{
-		UnaryExpression: UnaryExpression{Child: expr},
-		TargetCharSet:   targetCharSet,
+		UnaryExpressionStub: UnaryExpressionStub{Child: expr},
+		TargetCharSet:       targetCharSet,
 	}
 }
 

sql/expression/function/absval.go

@@ -25,15 +25,15 @@ import (
 
 // AbsVal is a function that takes the absolute value of a number
 type AbsVal struct {
-	expression.UnaryExpression
+	expression.UnaryExpressionStub
 }
 
 var _ sql.FunctionExpression = (*AbsVal)(nil)
 var _ sql.CollationCoercible = (*AbsVal)(nil)
 
 // NewAbsVal creates a new AbsVal expression.
 func NewAbsVal(e sql.Expression) sql.Expression {
-	return &AbsVal{expression.UnaryExpression{Child: e}}
+	return &AbsVal{expression.UnaryExpressionStub{Child: e}}
 }
 
 // FunctionName implements sql.FunctionExpression

sql/expression/function/aggregation/common.go

@@ -26,7 +26,7 @@ var ErrEvalUnsupportedOnAggregation = errors.NewKind("Unimplemented %s.Eval(). T
 // unaryAggBase is the generic embedded class optgen
 // uses to codegen single expression aggregate functions.
 type unaryAggBase struct {
-	expression.UnaryExpression
+	Child        sql.Expression
 	typ          sql.Type
 	window       *sql.WindowDefinition
 	functionName string
@@ -76,6 +76,11 @@ func (a *unaryAggBase) WithId(id sql.ColumnId) sql.IdExpression {
 	return &ret
 }
 
+// IsNullable returns whether the expression can be null.
+func (a *unaryAggBase) IsNullable() bool {
+	return a.Child.IsNullable()
+}
+
 // CollationCoercibility implements the interface sql.CollationCoercible.
 func (a *unaryAggBase) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte) {
 	return sql.GetCoercibility(ctx, a.Child)
@@ -96,7 +101,8 @@ func (a *unaryAggBase) Children() []sql.Expression {
 func (a *unaryAggBase) Resolved() bool {
 	if _, ok := a.Child.(*expression.Star); ok {
 		return true
-	} else if !a.Child.Resolved() {
+	}
+	if !a.Child.Resolved() {
 		return false
 	}
 	if a.window == nil {
@@ -112,7 +118,7 @@ func (a *unaryAggBase) WithChildren(children ...sql.Expression) (sql.Expression,
 	}
 
 	na := *a
-	na.UnaryExpression = expression.UnaryExpression{Child: children[0]}
+	na.Child = children[0]
 	if len(children) > 1 && a.window != nil {
 		w, err := a.window.FromExpressions(children[1:])
 		if err != nil {