Abstract IsNull and IsNotNull expression logic into an interface, so Doltgres can customize

Author: fulghum

sql/analyzer/costed_index_scan.go

@@ -652,7 +652,7 @@ func (c *indexCoster) getConstAndNullFilters(filters sql.FastIntSet) (sql.FastIn
 		switch e.(type) {
 		case *expression.Equals:
 			isConst.Add(i)
-		case *expression.IsNull:
+		case sql.IsNullExpression:
 			isNull.Add(i)
 		case *expression.NullSafeEquals:
 			isConst.Add(i)
@@ -1513,14 +1513,20 @@ func IndexLeafChildren(e sql.Expression) (IndexScanOp, sql.Expression, sql.Expre
 		left = e.Left()
 		right = e.Right()
 		op = IndexScanOpLte
-	case *expression.IsNull:
-		left = e.Child
+	case sql.IsNullExpression:
+		left = e.Children()[0]
 		op = IndexScanOpIsNull
+	case sql.IsNotNullExpression:
+		left = e.Children()[0]
+		op = IndexScanOpIsNotNull
 	case *expression.Not:
 		switch e := e.Child.(type) {
-		case *expression.IsNull:
-			left = e.Child
+		case sql.IsNullExpression:
+			left = e.Children()[0]
 			op = IndexScanOpIsNotNull
+			// TODO: In Postgres, Not(IS NULL) is valid, but doesn't necessarily always mean the
+			//       same thing as IS NOT NULL, particularly for the case of records or composite
+			//       values.
 		case *expression.Equals:
 			left = e.Left()
 			right = e.Right()

sql/analyzer/indexed_joins.go

@@ -567,7 +567,7 @@ func convertAntiToLeftJoin(m *memo.Memo) error {
 		// drop null projected columns on right table
 		nullFilters := make([]sql.Expression, len(nullify))
 		for i, e := range nullify {
-			nullFilters[i] = expression.NewIsNull(e)
+			nullFilters[i] = expression.DefaultExpressionFactory.NewIsNull(e)
 		}
 
 		filterGrp := m.MemoizeFilter(nil, joinGrp, nullFilters)
@@ -1405,14 +1405,16 @@ func makeIndexScan(ctx *sql.Context, statsProv sql.StatsProvider, tab plan.Table
 func isWeaklyMonotonic(e sql.Expression) bool {
 	return !transform.InspectExpr(e, func(e sql.Expression) bool {
 		switch e := e.(type) {
+		case sql.IsNullExpression:
+			return false
 		case expression.ArithmeticOp:
 			if e.Operator() == "-" {
 				// TODO minus can be OK if it's not on the GetField
 				return true
 			}
 			return false
 		case *expression.Equals, *expression.NullSafeEquals, *expression.Literal, *expression.GetField,
-			*expression.Tuple, *expression.IsNull, *expression.BindVar:
+			*expression.Tuple, *expression.BindVar:
 			return false
 		default:
 			if e, ok := e.(expression.Equality); ok && e.RepresentsEquality() {

sql/analyzer/optimization_rules.go

@@ -172,7 +172,7 @@ func expressionSources(expr sql.Expression) (sql.FastIntSet, bool) {
 		switch e := e.(type) {
 		case *expression.GetField:
 			tables.Add(int(e.TableId()))
-		case *expression.IsNull:
+		case sql.IsNullExpression:
 			nullRejecting = false
 		case *expression.NullSafeEquals:
 			nullRejecting = false
@@ -188,7 +188,7 @@ func expressionSources(expr sql.Expression) (sql.FastIntSet, bool) {
 				switch e := innerExpr.(type) {
 				case *expression.GetField:
 					tables.Add(int(e.TableId()))
-				case *expression.IsNull:
+				case sql.IsNullExpression:
 					nullRejecting = false
 				case *expression.NullSafeEquals:
 					nullRejecting = false

sql/core.go

@@ -65,6 +65,19 @@ type NonDeterministicExpression interface {
 	IsNonDeterministic() bool
 }
 
+// IsNullExpression indicates that this expression tests for IS NULL.
+type IsNullExpression interface {
+	Expression
+	IsNullExpression() bool
+}
+
+// IsNotNullExpression indicates that this expression tests for IS NOT NULL. Note that in some cases in some
+// database engines, such as records in Postgres, IS NOT NULL is not identical to NOT(IS NULL).
+type IsNotNullExpression interface {
+	Expression
+	IsNotNullExpression() bool
+}
+
 // Node is a node in the execution plan tree.
 type Node interface {
 	Resolvable

sql/expression/expr-factory.go

@@ -0,0 +1,50 @@
+// Copyright 2025 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package expression
+
+import "github.com/dolthub/go-mysql-server/sql"
+
+// ExpressionFactory allows integrators to provide custom implementations of
+// expressions, such as IS NULL and IS NOT NULL.
+type ExpressionFactory interface {
+	// NewIsNull returns a sql.Expression implementation that handles
+	// the IS NULL expression.
+	NewIsNull(e sql.Expression) sql.Expression
+	// NewIsNotNull returns a sql.Expression implementation that handles
+	// the IS NOT NULL expression.
+	NewIsNotNull(e sql.Expression) sql.Expression
+}
+
+// DefaultExpressionFactory is the ExpressionFactory used when the analyzer
+// needs to create new expressions during analysis, such as IS NULL or
+// IS NOT NULL. Integrators can swap in their own implementation if they need
+// to customize the existing logic for these expressions.
+var DefaultExpressionFactory ExpressionFactory = MySqlExpressionFactory{}
+
+// MySqlExpressionFactory is the ExpressionFactory that creates expressions
+// that follow MySQL's logic.
+type MySqlExpressionFactory struct{}
+
+var _ ExpressionFactory = (*MySqlExpressionFactory)(nil)
+
+// NewIsNull implements the ExpressionFactory interface.
+func (m MySqlExpressionFactory) NewIsNull(e sql.Expression) sql.Expression {
+	return NewIsNull(e)
+}
+
+// NewIsNotNull implements the ExpressionFactory interface.
+func (m MySqlExpressionFactory) NewIsNotNull(e sql.Expression) sql.Expression {
+	return NewNot(NewIsNull(e))
+}

sql/expression/filter-range.go

@@ -48,24 +48,24 @@ func NewRangeFilterExpr(exprs []sql.Expression, ranges []sql.MySQLRange) (sql.Ex
 			case sql.RangeType_All:
 				rangeColumnExpr = NewEquals(NewLiteral(1, types.Int8), NewLiteral(1, types.Int8))
 			case sql.RangeType_EqualNull:
-				rangeColumnExpr = NewIsNull(exprs[i])
+				rangeColumnExpr = DefaultExpressionFactory.NewIsNull(exprs[i])
 			case sql.RangeType_GreaterThan:
 				if sql.MySQLRangeCutIsBinding(rce.LowerBound) {
 					rangeColumnExpr = NewGreaterThan(exprs[i], NewLiteral(sql.GetMySQLRangeCutKey(rce.LowerBound), rce.Typ.Promote()))
 				} else {
-					rangeColumnExpr = NewNot(NewIsNull(exprs[i]))
+					rangeColumnExpr = DefaultExpressionFactory.NewIsNotNull(exprs[i])
 				}
 			case sql.RangeType_GreaterOrEqual:
 				rangeColumnExpr = NewGreaterThanOrEqual(exprs[i], NewLiteral(sql.GetMySQLRangeCutKey(rce.LowerBound), rce.Typ.Promote()))
 			case sql.RangeType_LessThanOrNull:
 				rangeColumnExpr = JoinOr(
 					NewLessThan(exprs[i], NewLiteral(sql.GetMySQLRangeCutKey(rce.UpperBound), rce.Typ.Promote())),
-					NewIsNull(exprs[i]),
+					DefaultExpressionFactory.NewIsNull(exprs[i]),
 				)
 			case sql.RangeType_LessOrEqualOrNull:
 				rangeColumnExpr = JoinOr(
 					NewLessThanOrEqual(exprs[i], NewLiteral(sql.GetMySQLRangeCutKey(rce.UpperBound), rce.Typ.Promote())),
-					NewIsNull(exprs[i]),
+					DefaultExpressionFactory.NewIsNull(exprs[i]),
 				)
 			case sql.RangeType_ClosedClosed:
 				rangeColumnExpr = JoinAnd(

sql/expression/isnull.go

@@ -26,12 +26,19 @@ type IsNull struct {
 
 var _ sql.Expression = (*IsNull)(nil)
 var _ sql.CollationCoercible = (*IsNull)(nil)
+var _ sql.IsNullExpression = (*IsNull)(nil)
 
 // NewIsNull creates a new IsNull expression.
 func NewIsNull(child sql.Expression) *IsNull {
 	return &IsNull{UnaryExpression{child}}
 }
 
+// IsNullExpression implements the sql.IsNullExpression interface. This function exsists primarily
+// to ensure the IsNullExpression interface has a unique signature.
+func (e *IsNull) IsNullExpression() bool {
+	return true
+}
+
 // Type implements the Expression interface.
 func (e *IsNull) Type() sql.Type {
 	return types.Boolean
@@ -53,18 +60,6 @@ func (e *IsNull) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	if err != nil {
 		return nil, err
 	}
-
-	// Slices of typed values (e.g. Record and Composite types in Postgres) evaluate
-	// to NULL if all of their entries are NULL.
-	if tupleValue, ok := v.([]types.TupleValue); ok {
-		for _, typedValue := range tupleValue {
-			if typedValue.Value != nil {
-				return false, nil
-			}
-		}
-		return true, nil
-	}
-
 	return v == nil, nil
 }
 

sql/memo/rel_props.go

@@ -285,9 +285,9 @@ func (p *relProps) populateFds() {
 					}
 				}
 			case *expression.Not:
-				child, ok := f.Child.(*expression.IsNull)
+				child, ok := f.Child.(sql.IsNullExpression)
 				if ok {
-					col, ok := child.Child.(*expression.GetField)
+					col, ok := child.Children()[0].(*expression.GetField)
 					if ok {
 						notNull.Add(col.Id())
 					}

sql/plan/join.go

@@ -531,9 +531,12 @@ func NewSemiJoin(left, right sql.Node, cond sql.Expression) *JoinNode {
 // IsNullRejecting returns whether the expression always returns false for
 // nil inputs.
 func IsNullRejecting(e sql.Expression) bool {
+	// Note that InspectExpr will stop inspecting expressions in the
+	// expression tree when true is returned, so we invert that return
+	// value from InspectExpr to return the correct null rejecting value.
 	return !transform.InspectExpr(e, func(e sql.Expression) bool {
 		switch e.(type) {
-		case *expression.NullSafeEquals, *expression.IsNull:
+		case sql.IsNullExpression, *expression.NullSafeEquals:
 			return true
 		default:
 			return false

sql/planbuilder/scalar.go

@@ -747,10 +747,10 @@ func (b *Builder) buildIsExprToExpression(inScope *scope, c *ast.IsExpr) sql.Exp
 	e := b.buildScalar(inScope, c.Expr)
 	switch strings.ToLower(c.Operator) {
 	case ast.IsNullStr:
-		return expression.NewIsNull(e)
+		return expression.DefaultExpressionFactory.NewIsNull(e)
 	case ast.IsNotNullStr:
 		b.qFlags.Set(sql.QFlgNotExpr)
-		return expression.NewNot(expression.NewIsNull(e))
+		return expression.DefaultExpressionFactory.NewIsNotNull(e)
 	case ast.IsTrueStr:
 		return expression.NewIsTrue(e)
 	case ast.IsFalseStr: