plan, executor: check b.err when building logical plan(#7114)(#7204)

executor/prepared_test.go

@@ -263,4 +263,7 @@ func (s *testSuite) TestPreparedNameResolver(c *C) {
 	tk.MustExec("prepare stmt from 'select * from t limit ? offset ?'")
 	_, err := tk.Exec("prepare stmt from 'select b from t'")
 	c.Assert(err.Error(), Equals, "[planner:1054]Unknown column 'b' in 'field list'")
+
+	_, err = tk.Exec("prepare stmt from '(select * FROM t) union all (select * FROM t) order by a limit ?'")
+	c.Assert(err.Error(), Equals, "[planner:1054]Unknown column 'a' in 'order clause'")
 }

executor/write_test.go

@@ -866,6 +866,11 @@ func (s *testSuite) TestUpdate(c *C) {
 	tk.MustQuery("show warnings").Check(testkit.Rows("Warning 1265 Data Truncated"))
 	r = tk.MustQuery("select * from decimals")
 	r.Check(testkit.Rows("202"))
+
+	tk.MustExec("drop table t")
+	tk.MustExec("CREATE TABLE `t` (	`c1` year DEFAULT NULL, `c2` year DEFAULT NULL, `c3` date DEFAULT NULL, `c4` datetime DEFAULT NULL,	KEY `idx` (`c1`,`c2`))")
+	_, err = tk.Exec("UPDATE t SET c2=16777215 WHERE c1>= -8388608 AND c1 < -9 ORDER BY c1 LIMIT 2")
+	c.Assert(err.Error(), Equals, "cannot convert datum from bigint to type year.")
 }
 
 // TestUpdateCastOnlyModifiedValues for issue #4514.

plan/logical_plan_builder.go

@@ -143,6 +143,7 @@ func (b *planBuilder) buildResultSetNode(node ast.ResultSetNode) LogicalPlan {
 			b.err = ErrUnsupportedType.GenByArgs(v)
 		}
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 		if v, ok := p.(*DataSource); ok {
@@ -277,11 +278,13 @@ func (b *planBuilder) buildJoin(joinNode *ast.Join) LogicalPlan {
 
 	leftPlan := b.buildResultSetNode(joinNode.Left)
 	if b.err != nil {
+		b.err = errors.Trace(b.err)
 		return nil
 	}
 
 	rightPlan := b.buildResultSetNode(joinNode.Right)
 	if b.err != nil {
+		b.err = errors.Trace(b.err)
 		return nil
 	}
 	joinPlan := LogicalJoin{StraightJoin: joinNode.StraightJoin || b.inStraightJoin}.init(b.ctx)
@@ -712,9 +715,17 @@ func (b *planBuilder) buildUnion(union *ast.UnionStmt) LogicalPlan {
 
 	if union.OrderBy != nil {
 		unionPlan = b.buildSort(unionPlan, union.OrderBy.Items, nil)
+		if b.err != nil {
+			b.err = errors.Trace(b.err)
+			return nil
+		}
 	}
 	if union.Limit != nil {
 		unionPlan = b.buildLimit(unionPlan, union.Limit)
+		if b.err != nil {
+			b.err = errors.Trace(b.err)
+			return nil
+		}
 	}
 	return unionPlan
 }
@@ -1564,16 +1575,19 @@ func (b *planBuilder) buildSelect(sel *ast.SelectStmt) LogicalPlan {
 		p = b.buildTableDual()
 	}
 	if b.err != nil {
+		b.err = errors.Trace(b.err)
 		return nil
 	}
 	originalFields := sel.Fields.Fields
 	sel.Fields.Fields = b.unfoldWildStar(p, sel.Fields.Fields)
 	if b.err != nil {
+		b.err = errors.Trace(b.err)
 		return nil
 	}
 	if sel.GroupBy != nil {
 		p, gbyCols = b.resolveGbyExprs(p, sel.GroupBy, sel.Fields.Fields)
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 		if b.ctx.GetSessionVars().SQLMode.HasOnlyFullGroupBy() {
@@ -1587,6 +1601,7 @@ func (b *planBuilder) buildSelect(sel *ast.SelectStmt) LogicalPlan {
 	if sel.Where != nil {
 		p = b.buildSelection(p, sel.Where, nil)
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 	}
@@ -1597,6 +1612,7 @@ func (b *planBuilder) buildSelect(sel *ast.SelectStmt) LogicalPlan {
 	if hasAgg {
 		aggFuncs, totalMap = b.extractAggFuncs(sel.Fields.Fields)
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 		var aggIndexMap map[int]int
@@ -1605,36 +1621,42 @@ func (b *planBuilder) buildSelect(sel *ast.SelectStmt) LogicalPlan {
 			totalMap[k] = aggIndexMap[v]
 		}
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 	}
 	var oldLen int
 	p, oldLen = b.buildProjection(p, sel.Fields.Fields, totalMap)
 	if b.err != nil {
+		b.err = errors.Trace(b.err)
 		return nil
 	}
 	if sel.Having != nil {
 		b.curClause = havingClause
 		p = b.buildSelection(p, sel.Having.Expr, havingMap)
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 	}
 	if sel.Distinct {
 		p = b.buildDistinct(p, oldLen)
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 	}
 	if sel.OrderBy != nil {
 		p = b.buildSort(p, sel.OrderBy.Items, orderMap)
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 	}
 	if sel.Limit != nil {
 		p = b.buildLimit(p, sel.Limit)
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 	}
@@ -1966,6 +1988,7 @@ func (b *planBuilder) buildUpdate(update *ast.UpdateStmt) Plan {
 	sel := &ast.SelectStmt{Fields: &ast.FieldList{}, From: update.TableRefs, Where: update.Where, OrderBy: update.Order, Limit: update.Limit}
 	p := b.buildResultSetNode(sel.From.TableRefs)
 	if b.err != nil {
+		b.err = errors.Trace(b.err)
 		return nil
 	}
 
@@ -1982,23 +2005,27 @@ func (b *planBuilder) buildUpdate(update *ast.UpdateStmt) Plan {
 	if sel.Where != nil {
 		p = b.buildSelection(p, sel.Where, nil)
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 	}
 	if sel.OrderBy != nil {
 		p = b.buildSort(p, sel.OrderBy.Items, nil)
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 	}
 	if sel.Limit != nil {
 		p = b.buildLimit(p, sel.Limit)
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 	}
 	orderedList, np := b.buildUpdateLists(tableList, update.List, p)
 	if b.err != nil {
+		b.err = errors.Trace(b.err)
 		return nil
 	}
 	p = np
@@ -2009,6 +2036,10 @@ func (b *planBuilder) buildUpdate(update *ast.UpdateStmt) Plan {
 	}.init(b.ctx)
 	updt.SetSchema(p.Schema())
 	updt.SelectPlan, b.err = doOptimize(b.optFlag, p)
+	if b.err != nil {
+		b.err = errors.Trace(b.err)
+		return nil
+	}
 	updt.ResolveIndices()
 	return updt
 }
@@ -2140,24 +2171,28 @@ func (b *planBuilder) buildDelete(delete *ast.DeleteStmt) Plan {
 	}
 	p := b.buildResultSetNode(sel.From.TableRefs)
 	if b.err != nil {
+		b.err = errors.Trace(b.err)
 		return nil
 	}
 
 	if sel.Where != nil {
 		p = b.buildSelection(p, sel.Where, nil)
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 	}
 	if sel.OrderBy != nil {
 		p = b.buildSort(p, sel.OrderBy.Items, nil)
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 	}
 	if sel.Limit != nil {
 		p = b.buildLimit(p, sel.Limit)
 		if b.err != nil {
+			b.err = errors.Trace(b.err)
 			return nil
 		}
 	}
@@ -2173,6 +2208,7 @@ func (b *planBuilder) buildDelete(delete *ast.DeleteStmt) Plan {
 	}.init(b.ctx)
 	del.SelectPlan, b.err = doOptimize(b.optFlag, p)
 	if b.err != nil {
+		b.err = errors.Trace(b.err)
 		return nil
 	}
 	del.SetSchema(expression.NewSchema())

types/datum.go

@@ -1556,7 +1556,7 @@ func (d *Datum) ToMysqlJSON() (j json.BinaryJSON, err error) {
 }
 
 func invalidConv(d *Datum, tp byte) (Datum, error) {
-	return Datum{}, errors.Errorf("cannot convert datum from %s to type %s.", TypeStr(d.Kind()), TypeStr(tp))
+	return Datum{}, errors.Errorf("cannot convert datum from %s to type %s.", KindStr(d.Kind()), TypeStr(tp))
 }
 
 func (d *Datum) convergeType(hasUint, hasDecimal, hasFloat *bool) (x Datum) {

types/etc.go

@@ -102,6 +102,28 @@ func IsNonBinaryStr(ft *FieldType) bool {
 	return false
 }
 
+var kind2Str = map[byte]string{
+	KindNull:          "null",
+	KindInt64:         "bigint",
+	KindUint64:        "unsigned bigint",
+	KindFloat32:       "float",
+	KindFloat64:       "double",
+	KindString:        "char",
+	KindBytes:         "bytes",
+	KindBinaryLiteral: "bit/hex literal",
+	KindMysqlDecimal:  "decimal",
+	KindMysqlDuration: "time",
+	KindMysqlEnum:     "enum",
+	KindMysqlBit:      "bit",
+	KindMysqlSet:      "set",
+	KindMysqlTime:     "datetime",
+	KindInterface:     "interface",
+	KindMinNotNull:    "min_not_null",
+	KindMaxValue:      "max_value",
+	KindRaw:           "raw",
+	KindMysqlJSON:     "json",
+}
+
 var type2Str = map[byte]string{
 	mysql.TypeBit:        "bit",
 	mysql.TypeBlob:       "text",
@@ -137,6 +159,11 @@ func TypeStr(tp byte) (r string) {
 	return type2Str[tp]
 }
 
+// KindStr converts kind to a string.
+func KindStr(kind byte) (r string) {
+	return kind2Str[kind]
+}
+
 // TypeToStr converts a field to a string.
 // It is used for converting Text to Blob,
 // or converting Char to Binary.