test

Author: James Cor

sql/analyzer/inserts.go

@@ -29,43 +29,49 @@ import (
 )
 
 func resolveInsertRows(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scope, sel RuleSelector, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
-	if _, ok := n.(*plan.TriggerExecutor); ok {
-		return n, transform.SameTree, nil
-	} else if _, ok := n.(*plan.CreateProcedure); ok {
+	switch n.(type) {
+	case *plan.TriggerExecutor, *plan.CreateProcedure:
 		return n, transform.SameTree, nil
 	}
+
 	// We capture all INSERTs along the tree, such as those inside of block statements.
-	return transform.Node(n, func(n sql.Node) (sql.Node, transform.TreeIdentity, error) {
+	var selFunc transform.SelectorFunc = func(c transform.Context) bool {
+		switch c.Node.(type) {
+		case *plan.InsertInto:
+			return true
+		default:
+			return false
+		}
+	}
+
+	var ctxFunc transform.CtxFunc = func(c transform.Context) (sql.Node, transform.TreeIdentity, error) {
 		insert, ok := n.(*plan.InsertInto)
 		if !ok {
 			return n, transform.SameTree, nil
 		}
 
+		source := insert.Source
 		table := getResolvedTable(insert.Destination)
-
 		insertable, err := plan.GetInsertable(table)
 		if err != nil {
 			return nil, transform.SameTree, err
 		}
+		dstSchema := insertable.Schema()
 
-		source := insert.Source
-		// TriggerExecutor has already been analyzed
-		if _, ok := insert.Source.(*plan.TriggerExecutor); !ok && !insert.LiteralValueSource {
-			// Analyze the source of the insert independently
-			if _, ok := insert.Source.(*plan.Values); ok {
+		// Analyze the source of the insert independently
+		if !insert.LiteralValueSource {
+			if _, isValues := source.(*plan.Values); isValues {
 				scope = scope.NewScope(plan.NewProject(
-					expression.SchemaToGetFields(insert.Source.Schema()[:len(insert.ColumnNames)], sql.ColSet{}),
-					plan.NewSubqueryAlias("dummy", "", insert.Source),
+					expression.SchemaToGetFields(source.Schema()[:len(insert.ColumnNames)], sql.ColSet{}),
+					plan.NewSubqueryAlias("dummy", "", source),
 				))
 			}
-			source, _, err = a.analyzeWithSelector(ctx, insert.Source, scope, SelectAllBatches, newInsertSourceSelector(sel), qFlags)
+			source, _, err = a.analyzeWithSelector(ctx, source, scope, SelectAllBatches, newInsertSourceSelector(sel), qFlags)
 			if err != nil {
 				return nil, transform.SameTree, err
 			}
 		}
 
-		dstSchema := insertable.Schema()
-
 		// normalize the column name
 		columnNames := make([]string, len(insert.ColumnNames))
 		for i, name := range insert.ColumnNames {
@@ -81,13 +87,15 @@ func resolveInsertRows(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Sc
 		}
 
 		// The schema of the destination node and the underlying table differ subtly in terms of defaults
-		project, firstGeneratedAutoIncRowIdx, err := wrapRowSource(ctx, source, insertable, insert.Destination.Schema(), columnNames)
+		project, firstGeneratedAutoIncRowIdx, err := wrapRowSource(ctx, source, insertable, dstSchema, columnNames)
 		if err != nil {
 			return nil, transform.SameTree, err
 		}
 
-		return insert.WithSource(project).WithAutoIncrementIdx(firstGeneratedAutoIncRowIdx), transform.NewTree, nil
-	})
+		newInsert := insert.WithSource(project).WithAutoIncrementIdx(firstGeneratedAutoIncRowIdx)
+		return newInsert, transform.NewTree, nil
+	}
+	return transform.NodeWithCtx(n, selFunc, ctxFunc)
 }
 
 func validateInsertRows(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scope, sel RuleSelector, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
@@ -177,6 +185,19 @@ func findColIdx(colName string, colNames []string) int {
 // the underlying table in the same order. Also, returns an integer value that indicates when this row source will
 // result in an automatically generated value for an auto_increment column.
 func wrapRowSource(ctx *sql.Context, insertSource sql.Node, destTbl sql.Table, schema sql.Schema, columnNames []string) (sql.Node, int, error) {
+	// if source is a triggerExec node, we need to wrap the child in the project not the triggerExec node itself
+	if trigExec, isTrigExec := insertSource.(*plan.TriggerExecutor); isTrigExec {
+		newLeft, firstGeneratedAutoIncRowIdx, err := wrapRowSource(ctx, trigExec.Left(), destTbl, schema, columnNames)
+		if err != nil {
+			return nil, -1, err
+		}
+		newTrigExec, err := trigExec.WithChildren(newLeft, trigExec.Right())
+		if err != nil {
+			return nil, -1, err
+		}
+		return newTrigExec, firstGeneratedAutoIncRowIdx, nil
+	}
+
 	projExprs := make([]sql.Expression, len(schema))
 	firstGeneratedAutoIncRowIdx := -1
 
@@ -188,6 +209,10 @@ func wrapRowSource(ctx *sql.Context, insertSource sql.Node, destTbl sql.Table, s
 				defaultExpr = col.Generated
 			}
 
+			if !col.Nullable && defaultExpr == nil && !col.AutoIncrement {
+				return nil, -1, sql.ErrInsertIntoNonNullableDefaultNullColumn.New(col.Name)
+			}
+
 			var err error
 			colNameToIdx := make(map[string]int)
 			for i, c := range schema {
@@ -227,26 +252,30 @@ func wrapRowSource(ctx *sql.Context, insertSource sql.Node, destTbl sql.Table, s
 				firstGeneratedAutoIncRowIdx = 0
 			} else {
 				// Additionally, the first NULL, DEFAULT, or empty value is what the last_insert_id should be set to.
-				switch src := insertSource.(type) {
-				case *plan.Values:
-					for ii, tup := range src.ExpressionTuples {
-						expr := tup[colIdx]
-						if unwrap, ok := expr.(*expression.Wrapper); ok {
-							expr = unwrap.Unwrap()
-						}
-						if _, isDef := expr.(*sql.ColumnDefaultValue); isDef {
-							firstGeneratedAutoIncRowIdx = ii
-							break
-						}
-						if lit, isLit := expr.(*expression.Literal); isLit {
-							// If a literal NULL or if 0 is specified and the NO_AUTO_VALUE_ON_ZERO SQL mode is
-							// not active, then MySQL will fill in an auto_increment value.
-							if types.Null.Equals(lit.Type()) ||
-								(!sql.LoadSqlMode(ctx).ModeEnabled(sql.NoAutoValueOnZero) && isZero(lit)) {
-								firstGeneratedAutoIncRowIdx = ii
-								break
-							}
-						}
+				src, isValues := insertSource.(*plan.Values)
+				if !isValues {
+					continue
+				}
+
+				for ii, tup := range src.ExpressionTuples {
+					expr := tup[colIdx]
+					if unwrap, ok := expr.(*expression.Wrapper); ok {
+						expr = unwrap.Unwrap()
+					}
+					if _, isDef := expr.(*sql.ColumnDefaultValue); isDef {
+						firstGeneratedAutoIncRowIdx = ii
+						break
+					}
+					lit, isLit := expr.(*expression.Literal)
+					if !isLit {
+						continue
+					}
+					// If a literal NULL or if 0 is specified and the NO_AUTO_VALUE_ON_ZERO SQL mode is
+					// not active, then MySQL will fill in an auto_increment value.
+					if types.Null.Equals(lit.Type()) ||
+						(!sql.LoadSqlMode(ctx).ModeEnabled(sql.NoAutoValueOnZero) && isZero(lit)) {
+						firstGeneratedAutoIncRowIdx = ii
+						break
 					}
 				}
 			}

sql/analyzer/rules.go

@@ -17,10 +17,8 @@ package analyzer
 func init() {
 	OnceAfterAll = []Rule{
 		{assignExecIndexesId, assignExecIndexes},
-		// resolveInsertRows inserts a projection wrapping values that cannot be seen by fixup
-		{resolveInsertRowsId, resolveInsertRows},
 		{applyTriggersId, applyTriggers},
-		{validateInsertRowsId, validateInsertRows},
+		{resolveInsertRowsId, resolveInsertRows},
 		{applyProceduresId, applyProcedures},
 		{inlineSubqueryAliasRefsId, inlineSubqueryAliasRefs},
 		{cacheSubqueryAliasesInJoinsId, cacheSubqueryAliasesInJoins},

sql/planbuilder/dml.go

@@ -181,15 +181,16 @@ func (b *Builder) buildInsertValues(inScope *scope, v *ast.AliasedValues, column
 	for i, columnName := range columnNames {
 		index := destSchema.IndexOfColName(columnName)
 		if index == -1 {
+			// ignore missing columns when in trigger context
 			if !b.TriggerCtx().Call && len(b.TriggerCtx().UnresolvedTables) > 0 {
 				continue
 			}
-			err := sql.ErrUnknownColumn.New(columnName, tableName)
-			b.handleErr(err)
+			b.handleErr(sql.ErrUnknownColumn.New(columnName, tableName))
 		}
 
-		columnDefaultValues[i] = destSchema[index].Default
-		if columnDefaultValues[i] == nil && destSchema[index].Generated != nil {
+		if destSchema[index].Default != nil {
+			columnDefaultValues[i] = destSchema[index].Default
+		} else if columnDefaultValues[i] == nil {
 			columnDefaultValues[i] = destSchema[index].Generated
 		}
 	}