*: make insert with calculated value behave the same as MySQL.

ast/expressions.go

@@ -345,6 +345,18 @@ func (n *ColumnName) Accept(v Visitor) (Node, bool) {
 	return v.Leave(n)
 }
 
+// String implements Stringer interface.
+func (n *ColumnName) String() string {
+	result := n.Name.L
+	if n.Table.L != "" {
+		result = n.Table.L + "." + result
+	}
+	if n.Schema.L != "" {
+		result = n.Schema.L + "." + result
+	}
+	return result
+}
+
 // ColumnNameExpr represents a column name expression.
 type ColumnNameExpr struct {
 	exprNode

executor/write.go

@@ -886,15 +886,56 @@ func (e *InsertValues) getRows(cols []*table.Column, ignoreErr bool) (rows [][]t
 }
 
 func (e *InsertValues) getRow(cols []*table.Column, list []expression.Expression, ignoreErr bool) ([]types.Datum, error) {
-	vals := make([]types.Datum, len(list))
+	row := make([]types.Datum, len(e.Table.Cols()))
+	hasValue := make([]bool, len(e.Table.Cols()))
+	if err := e.fillDefaultValues(row, ignoreErr); err != nil {
+		return nil, errors.Trace(err)
+	}
+
 	for i, expr := range list {
-		val, err := expr.Eval(nil)
-		vals[i] = val
+		val, err := expr.Eval(row)
+		if err != nil {
+			return nil, errors.Trace(err)
+		}
+		val, err = table.CastValue(e.ctx, val, cols[i].ToInfo())
+		if err != nil {
+			return nil, errors.Trace(err)
+		}
+
+		offset := cols[i].Offset
+		row[offset] = val
+		hasValue[offset] = true
 		if err != nil {
 			return nil, errors.Trace(err)
 		}
 	}
-	return e.fillRowData(cols, vals, ignoreErr)
+
+	return e.checkRowData(cols, len(list), hasValue, row, ignoreErr)
+}
+
+func (e *InsertValues) fillDefaultValues(row []types.Datum, ignoreErr bool) error {
+	var defaultValueCols []*table.Column
+	for i, c := range e.Table.Cols() {
+		var err error
+		if c.IsGenerated() {
+			continue
+		} else if mysql.HasAutoIncrementFlag(c.Flag) {
+			row[i] = table.GetZeroValue(c.ToInfo())
+		} else {
+			row[i], err = table.GetColDefaultValue(e.ctx, c.ToInfo())
+			if table.IsNoDefault(err) && mysql.HasNotNullFlag(c.Flag) {
+				row[i] = table.GetZeroValue(c.ToInfo())
+			} else if err != nil {
+				return errors.Trace(err)
+			}
+		}
+		defaultValueCols = append(defaultValueCols, c)
+	}
+	if err := table.CastValues(e.ctx, row, defaultValueCols, ignoreErr); err != nil {
+		return errors.Trace(err)
+	}
+
+	return nil
 }
 
 func (e *InsertValues) getRowsSelect(cols []*table.Column, ignoreErr bool) ([][]types.Datum, error) {
@@ -929,6 +970,11 @@ func (e *InsertValues) fillRowData(cols []*table.Column, vals []types.Datum, ign
 		row[offset] = v
 		hasValue[offset] = true
 	}
+
+	return e.checkRowData(cols, len(vals), hasValue, row, ignoreErr)
+}
+
+func (e *InsertValues) checkRowData(cols []*table.Column, valLen int, hasValue []bool, row []types.Datum, ignoreErr bool) ([]types.Datum, error) {
 	err := e.initDefaultValues(row, hasValue, ignoreErr)
 	if err != nil {
 		return nil, errors.Trace(err)
@@ -939,7 +985,7 @@ func (e *InsertValues) fillRowData(cols []*table.Column, vals []types.Datum, ign
 		if err = e.filterErr(err, ignoreErr); err != nil {
 			return nil, errors.Trace(err)
 		}
-		offset := cols[len(vals)+i].Offset
+		offset := cols[valLen+i].Offset
 		row[offset] = val
 	}
 	if err = table.CastValues(e.ctx, row, cols, ignoreErr); err != nil {
@@ -980,6 +1026,9 @@ func (e *InsertValues) initDefaultValues(row []types.Datum, hasValue []bool, ign
 			// Just leave generated column as null. It will be calculated later
 			// but before we check whether the column can be null or not.
 			needDefaultValue = false
+			if !hasValue[i] {
+				row[i].SetNull()
+			}
 		}
 		if needDefaultValue {
 			var err error

executor/write_test.go

@@ -1171,3 +1171,106 @@ func (s *testSuite) TestIssue4067(c *C) {
 	tk.MustExec("delete from t1 where id in (select id from t2)")
 	tk.MustQuery("select * from t1").Check(nil)
 }
+
+func (s *testSuite) TestInsertCalculatedValue(c *C) {
+	tk := testkit.NewTestKit(c, s.store)
+	tk.MustExec("use test")
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a int, b int)")
+	tk.MustExec("insert into t set a=1, b=a+1")
+	tk.MustQuery("select a, b from t").Check(testkit.Rows("1 2"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a int default 100, b int)")
+	tk.MustExec("insert into t set b=a+1, a=1")
+	tk.MustQuery("select a, b from t").Check(testkit.Rows("1 101"))
+	tk.MustExec("insert into t (b) value (a)")
+	tk.MustQuery("select * from t where b = 100").Check(testkit.Rows("100 100"))
+	tk.MustExec("insert into t set a=2, b=a+1")
+	tk.MustQuery("select * from t where a = 2").Check(testkit.Rows("2 3"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t (c int)")
+	tk.MustExec("insert into test.t set test.t.c = '1'")
+	tk.MustQuery("select * from t").Check(testkit.Rows("1"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a int default 1)")
+	tk.MustExec("insert into t values (a)")
+	tk.MustQuery("select * from t").Check(testkit.Rows("1"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t (a int, b int, c int, d int)")
+	tk.MustExec("insert into t value (1, 2, a+1, b+1)")
+	tk.MustQuery("select * from t").Check(testkit.Rows("1 2 2 3"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t (a int not null)")
+	tk.MustExec("insert into t values (a+2)")
+	tk.MustExec("insert into t values (a)")
+	tk.MustQuery("select * from t order by a").Check(testkit.Rows("0", "2"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t (a bigint not null, b bigint not null)")
+	tk.MustExec("insert into t value(b + 1, a)")
+	tk.MustExec("insert into t set a = b + a, b = a + 1")
+	tk.MustExec("insert into t value(1000, a)")
+	tk.MustQuery("select * from t order by a").Check(testkit.Rows("0 1", "1 1", "1000 1000"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a int)")
+	tk.MustExec("insert into t values(a)")
+	tk.MustQuery("select * from t").Check(testkit.Rows("<nil>"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a enum('a', 'b'))")
+	tk.MustExec("insert into t values(a)")
+	tk.MustQuery("select * from t").Check(testkit.Rows("<nil>"))
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a enum('a', 'b') default 'a')")
+	tk.MustExec("insert into t values(a)")
+	tk.MustExec("insert into t values(a+1)")
+	tk.MustQuery("select * from t order by a").Check(testkit.Rows("a", "b"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a blob)")
+	tk.MustExec("insert into t values(a)")
+	tk.MustQuery("select * from t").Check(testkit.Rows("<nil>"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a varchar(20) default 'a')")
+	tk.MustExec("insert into t values(a)")
+	tk.MustExec("insert into t values(upper(a))")
+	tk.MustQuery("select * from t order by a").Check(testkit.Rows("A", "a"))
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a varchar(20) not null, b varchar(20))")
+	tk.MustExec("insert into t value (a, b)")
+	tk.MustQuery("select * from t").Check(testkit.Rows(" <nil>"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a int, b int)")
+	tk.MustExec("insert into t values(a*b, b*b)")
+	tk.MustQuery("select * from t").Check(testkit.Rows("<nil> <nil>"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t (a json not null, b int)")
+	tk.MustExec("insert into t value (a,a->'$')")
+	tk.MustQuery("select * from t").Check(testkit.Rows("null 0"))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a json, b int, c int as (a->'$.a'))")
+	tk.MustExec("insert into t (a, b) value (a, a->'$.a'+1)")
+	tk.MustExec("insert into t (b) value (a->'$.a'+1)")
+	tk.MustQuery("select * from t").Check(testkit.Rows("<nil> <nil> <nil>", "<nil> <nil> <nil>"))
+	tk.MustExec(`insert into t (a, b) value ('{"a": 1}', a->'$.a'+1)`)
+	tk.MustQuery("select * from t where c = 1").Check(testkit.Rows(`{"a":1} 2 1`))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a int auto_increment key, b int)")
+	tk.MustExec("insert into t (b) value (a)")
+	tk.MustExec("insert into t value (a, a+1)")
+	tk.MustExec("set SQL_MODE=NO_AUTO_VALUE_ON_ZERO")
+	tk.MustExec("insert into t (b) value (a+1)")
+	tk.MustQuery("select * from t order by a").Check(testkit.Rows("1 0", "2 1", "3 1"))
+}

expression/expression.go

@@ -338,9 +338,14 @@ func EvaluateExprWithNull(ctx context.Context, schema *Schema, expr Expression)
 	}
 }
 
-// TableInfo2Schema converts table info to schema.
+// TableInfo2Schema converts table info to schema with empty DBName.
 func TableInfo2Schema(tbl *model.TableInfo) *Schema {
-	cols := ColumnInfos2Columns(tbl.Name, tbl.Columns)
+	return TableInfo2SchemaWithDBName(model.CIStr{}, tbl)
+}
+
+// TableInfo2SchemaWithDBName converts table info to schema.
+func TableInfo2SchemaWithDBName(dbName model.CIStr, tbl *model.TableInfo) *Schema {
+	cols := ColumnInfos2ColumnsWithDBName(dbName, tbl.Name, tbl.Columns)
 	keys := make([]KeyInfo, 0, len(tbl.Indices)+1)
 	for _, idx := range tbl.Indices {
 		if !idx.Unique || idx.State != model.StatePublic {
@@ -382,15 +387,22 @@ func TableInfo2Schema(tbl *model.TableInfo) *Schema {
 	return schema
 }
 
-// ColumnInfos2Columns converts a slice of ColumnInfo to a slice of Column.
+// ColumnInfos2Columns converts a slice of ColumnInfo to a slice of Column with empty DBName.
 func ColumnInfos2Columns(tblName model.CIStr, colInfos []*model.ColumnInfo) []*Column {
+	return ColumnInfos2ColumnsWithDBName(model.CIStr{}, tblName, colInfos)
+}
+
+// ColumnInfos2ColumnsWithDBName converts a slice of ColumnInfo to a slice of Column.
+func ColumnInfos2ColumnsWithDBName(dbName, tblName model.CIStr, colInfos []*model.ColumnInfo) []*Column {
 	columns := make([]*Column, 0, len(colInfos))
 	for i, col := range colInfos {
 		newCol := &Column{
 			ColName:  col.Name,
 			TblName:  tblName,
+			DBName:   dbName,
 			RetType:  &col.FieldType,
 			Position: i,
+			Index:    col.Offset,
 		}
 		columns = append(columns, newCol)
 	}

plan/expression_rewriter.go

@@ -1150,5 +1150,5 @@ func (er *expressionRewriter) toColumn(v *ast.ColumnName) {
 			return
 		}
 	}
-	er.err = ErrUnknownColumn.GenByArgs(v.Text(), "field list")
+	er.err = ErrUnknownColumn.GenByArgs(v.String(), "field list")
 }

plan/planbuilder.go

@@ -693,7 +693,8 @@ func (b *planBuilder) buildInsert(insert *ast.InsertStmt) Plan {
 		return nil
 	}
 	tableInfo := tn.TableInfo
-	schema := expression.TableInfo2Schema(tableInfo)
+	// Build Schema with DBName otherwise ColumnRef with DBName cannot match any Column in Schema
+	schema := expression.TableInfo2SchemaWithDBName(tn.Schema, tableInfo)
 	tableInPlan, ok := b.is.TableByID(tableInfo.ID)
 	if !ok {
 		b.err = errors.Errorf("Can't get table %s.", tableInfo.Name.O)
@@ -733,6 +734,9 @@ func (b *planBuilder) buildInsert(insert *ast.InsertStmt) Plan {
 		}
 	}
 
+	mockTablePlan := TableDual{}.init(b.allocator, b.ctx)
+	mockTablePlan.SetSchema(schema)
+
 	cols := insertPlan.Table.Cols()
 	maxValuesItemLength := 0 // the max length of items in VALUES list.
 	for _, valuesItem := range insert.Lists {
@@ -752,7 +756,7 @@ func (b *planBuilder) buildInsert(insert *ast.InsertStmt) Plan {
 					RetType: &val.Type,
 				}
 			} else {
-				expr, _, err = b.rewrite(valueItem, nil, nil, true)
+				expr, _, err = b.rewrite(valueItem, mockTablePlan, nil, true)
 			}
 			if err != nil {
 				b.err = errors.Trace(err)
@@ -784,8 +788,6 @@ func (b *planBuilder) buildInsert(insert *ast.InsertStmt) Plan {
 		}
 	}
 
-	mockTablePlan := TableDual{}.init(b.allocator, b.ctx)
-	mockTablePlan.SetSchema(schema)
 	for _, assign := range insert.Setlist {
 		col, err := schema.FindColumn(assign.Column)
 		if err != nil {
@@ -801,8 +803,6 @@ func (b *planBuilder) buildInsert(insert *ast.InsertStmt) Plan {
 			b.err = ErrBadGeneratedColumn.GenByArgs(assign.Column.Name.O, tableInfo.Name.O)
 			return nil
 		}
-		// Here we keep different behaviours with MySQL. MySQL allow set a = b, b = a and the result is NULL, NULL.
-		// It's unreasonable.
 		expr, _, err := b.rewrite(assign.Expr, mockTablePlan, nil, true)
 		if err != nil {
 			b.err = errors.Trace(err)

table/column.go

@@ -30,6 +30,7 @@ import (
 	"github.com/pingcap/tidb/mysql"
 	"github.com/pingcap/tidb/util/hack"
 	"github.com/pingcap/tidb/util/types"
+	"github.com/pingcap/tidb/util/types/json"
 )
 
 // Column provides meta data describing a table column.
@@ -344,6 +345,11 @@ func getColDefaultValueFromNil(ctx context.Context, col *model.ColumnInfo) (type
 	return types.Datum{}, errNoDefaultValue.Gen("Field '%s' doesn't have a default value", col.Name)
 }
 
+// IsNoDefault check if err is equal to errNoDefaultValue.
+func IsNoDefault(err error) bool {
+	return errNoDefaultValue.Equal(err)
+}
+
 // GetZeroValue gets zero value for given column type.
 func GetZeroValue(col *model.ColumnInfo) types.Datum {
 	var d types.Datum
@@ -378,6 +384,8 @@ func GetZeroValue(col *model.ColumnInfo) types.Datum {
 		d.SetMysqlSet(types.Set{})
 	case mysql.TypeEnum:
 		d.SetMysqlEnum(types.Enum{})
+	case mysql.TypeJSON:
+		d.SetMysqlJSON(json.CreateJSON(nil))
 	}
 	return d
 }