Support SQLMode ONLY_FULL_GROUP_BY and fix a join panic bug

executor/aggregate_test.go

@@ -14,11 +14,14 @@
 package executor_test
 
 import (
+	"github.com/juju/errors"
 	. "github.com/pingcap/check"
 	"github.com/pingcap/tidb/ast"
 	"github.com/pingcap/tidb/executor"
 	"github.com/pingcap/tidb/expression"
+	"github.com/pingcap/tidb/mysql"
 	"github.com/pingcap/tidb/plan"
+	"github.com/pingcap/tidb/terror"
 	"github.com/pingcap/tidb/util/testkit"
 )
 
@@ -349,9 +352,148 @@ func (s *testSuite) TestAggPushDown(c *C) {
 	tk.MustQuery("select a, count(b) from (select * from t union all select * from tt) k group by a").Check(testkit.Rows("1 2", "2 1"))
 }
 
+func (s *testSuite) TestOnlyFullGroupBy(c *C) {
+	tk := testkit.NewTestKit(c, s.store)
+	tk.MustExec("use test")
+	tk.MustExec("set sql_mode = 'ONLY_FULL_GROUP_BY'")
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a int not null primary key, b int not null, c int default null, d int not null, unique key I_b_c (b,c), unique key I_b_d (b,d))")
+	tk.MustExec("create table x(a int not null primary key, b int not null, c int default null, d int not null, unique key I_b_c (b,c), unique key I_b_d (b,d))")
+
+	// test AggregateFunc
+	tk.MustExec("select max(a) from t group by d")
+	// test incompatible with sql_mode = ONLY_FULL_GROUP_BY
+	var err error
+	var terr *terror.Error
+	_, err = tk.Exec("select * from t group by d")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	_, err = tk.Exec("select b-c from t group by b+c")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	_, err = tk.Exec("select (b-c)*(b+c), min(a) from t group by b+c, b-c")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	_, err = tk.Exec("select b between c and d from t group by b,c")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	_, err = tk.Exec("select case b when 1 then c when 2 then d else d end from t group by b,c")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	_, err = tk.Exec("select c > (select b from t) from t group by b")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	_, err = tk.Exec("select c is null from t group by b")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	_, err = tk.Exec("select c is true from t group by b")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	_, err = tk.Exec("select (c+b)*d from t group by c,d")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	_, err = tk.Exec("select b in (c,d) from t group by b,c")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	_, err = tk.Exec("select b like '%a' from t group by c")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	_, err = tk.Exec("select c REGEXP '1.*' from t group by b")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	_, err = tk.Exec("select -b from t group by c")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	// test compatible with sql_mode = ONLY_FULL_GROUP_BY
+	tk.MustExec("select a from t group by a,b,c")
+	tk.MustExec("select b from t group by b")
+	tk.MustExec("select b as e from t group by b")
+	tk.MustExec("select b+c from t group by b+c")
+	tk.MustExec("select b+c, min(a) from t group by b+c, b-c")
+	tk.MustExec("select b+c, min(a) from t group by b, c")
+	tk.MustExec("select b+c from t group by b,c")
+	tk.MustExec("select b between c and d from t group by b,c,d")
+	tk.MustExec("select case b when 1 then c when 2 then d else d end from t group by b,c,d")
+	tk.MustExec("select c > (select b from t) from t group by c")
+	tk.MustExec("select exists (select * from t) from t group by d;")
+	tk.MustExec("select c is null from t group by c")
+	tk.MustExec("select c is true from t group by c")
+	tk.MustExec("select (c+b)*d from t group by c,b,d")
+	tk.MustExec("select b in (c,d) from t group by b,c,d")
+	tk.MustExec("select b like '%a' from t group by b")
+	tk.MustExec("select c REGEXP '1.*' from t group by c")
+	tk.MustExec("select -b from t group by b")
+	// test functinal depend on primary key
+	tk.MustExec("select * from t group by a")
+	// test functional depend on unique not null columns
+	tk.MustExec("select * from t group by b,d")
+	// test functional depend on a unique null column
+	_, err = tk.Exec("select * from t group by b,c")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	// test functional dependency derived from keys in where condition
+	tk.MustExec("select * from t where c = d group by b, c")
+	tk.MustExec("select t.*, x.* from t, x where t.a = x.a group by t.a")
+	tk.MustExec("select t.*, x.* from t, x where t.b = x.b and t.d = x.d group by t.b, t.d")
+	tk.MustExec("select t.*, x.* from t, x where t.b = x.a group by t.b, t.d")
+	tk.MustExec("select t.b, x.* from t, x where t.b = x.a group by t.b")
+	_, err = tk.Exec("select t.*, x.* from t, x where t.c = x.a group by t.b, t.c")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	// test functional dependency derived from keys in join
+	tk.MustExec("select t.*, x.* from t inner join x on t.a = x.a group by t.a")
+	tk.MustExec("select t.*, x.* from t inner join x  on (t.b = x.b and t.d = x.d) group by t.b, x.d")
+	tk.MustExec("select t.b, x.* from t inner join x on t.b = x.b group by t.b, x.d")
+	tk.MustExec("select t.b, x.* from t left join x on t.b = x.b group by t.b, x.d")
+	tk.MustExec("select t.b, x.* from t left join x on x.b = t.b group by t.b, x.d")
+	tk.MustExec("select x.b, t.* from t right join x on x.b = t.b group by x.b, t.d")
+	tk.MustExec("select x.b, t.* from t right join x on t.b = x.b group by x.b, t.d")
+	_, err = tk.Exec("select t.b, x.* from t right join x on t.b = x.b group by t.b, x.d")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	_, err = tk.Exec("select t.b, x.* from t right join x on t.b = x.b group by t.b, x.d")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	// test functional dependency of derived table
+	tk.MustExec("select * from (select * from t) as e group by a")
+	tk.MustExec("select * from (select * from t) as e group by b,d")
+	_, err = tk.Exec("select * from (select * from t) as e group by b,c")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	// test order by
+	tk.MustExec("select c from t group by c,d order by d")
+	_, err = tk.Exec("select c from t group by c order by d")
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrFieldNotInGroupBy))
+	// test ambiguous column
+	_, err = tk.Exec("select c from t,x group by t.c")
+	c.Assert(err, NotNil)
+	terr = errors.Trace(err).(*errors.Err).Cause().(*terror.Error)
+	c.Assert(terr.Code(), Equals, terror.ErrCode(mysql.ErrNonUniq))
+}
+
 func (s *testSuite) TestHaving(c *C) {
 	tk := testkit.NewTestKitWithInit(c, s.store)
 
+	tk.MustExec("set sql_mode = 'STRICT_TRANS_TABLES,NO_ENGINE_SUBSTITUTION'")
 	tk.MustExec("drop table if exists t")
 	tk.MustExec("create table t (c1 int, c2 int, c3 int)")
 	tk.MustExec("insert into t values (1,2,3), (2, 3, 1), (3, 1, 2)")

executor/join_test.go

@@ -89,9 +89,12 @@ func (s *testSuite) TestNestedLoopJoin(c *C) {
 func (s *testSuite) TestJoinPanic(c *C) {
 	tk := testkit.NewTestKit(c, s.store)
 	tk.MustExec("use test")
+	tk.MustExec("set sql_mode = 'ONLY_FULL_GROUP_BY'")
 	tk.MustExec("drop table if exists events")
 	tk.MustExec("create table events (clock int, source int)")
 	tk.MustQuery("SELECT * FROM events e JOIN (SELECT MAX(clock) AS clock FROM events e2 GROUP BY e2.source) e3 ON e3.clock=e.clock")
+	_, err := tk.Exec("SELECT * FROM events e JOIN (SELECT clock FROM events e2 GROUP BY e2.source) e3 ON e3.clock=e.clock")
+	c.Check(err, NotNil)
 }
 
 func (s *testSuite) TestJoin(c *C) {

executor/show_test.go

@@ -334,8 +334,8 @@ func (s *testSuite) TestShowFullProcessList(c *C) {
 	fullSQL := "show                                                                                        full processlist"
 	simpSQL := "show                                                                                        processlist"
 
-	tk.MustQuery(fullSQL).Check(testutil.RowsWithSep("|", "218|   Query|0|2|"+fullSQL))
-	tk.MustQuery(simpSQL).Check(testutil.RowsWithSep("|", "218|   Query|0|2|"+simpSQL[:100]))
+	tk.MustQuery(fullSQL).Check(testutil.RowsWithSep("|", "220|   Query|0|2|"+fullSQL))
+	tk.MustQuery(simpSQL).Check(testutil.RowsWithSep("|", "220|   Query|0|2|"+simpSQL[:100]))
 
 	se.SetSessionManager(nil) // reset sm so other tests won't use this
 }

mysql/const.go

@@ -359,6 +359,9 @@ var AllColumnPrivs = []PrivilegeType{SelectPriv, InsertPriv, UpdatePriv}
 // AllPrivilegeLiteral is the string literal for All Privilege.
 const AllPrivilegeLiteral = "ALL PRIVILEGES"
 
+// DefaultSQLMode for GLOBAL_VARIABLES
+const DefaultSQLMode = "STRICT_TRANS_TABLES,NO_ENGINE_SUBSTITUTION"
+
 // DefaultLengthOfMysqlTypes is the map for default physical length of MySQL data types.
 // See http://dev.mysql.com/doc/refman/5.7/en/storage-requirements.html
 var DefaultLengthOfMysqlTypes = map[byte]int{
@@ -414,6 +417,11 @@ func (m SQLMode) HasErrorForDivisionByZeroMode() bool {
 	return m&ModeErrorForDivisionByZero == ModeErrorForDivisionByZero
 }
 
+// HasOnlyFullGroupBy detects if 'ONLY_FULL_GROUP_BY' mode is set in SQLMode
+func (m SQLMode) HasOnlyFullGroupBy() bool {
+	return m&ModeOnlyFullGroupBy == ModeOnlyFullGroupBy
+}
+
 // HasStrictMode detects if 'STRICT_TRANS_TABLES' or 'STRICT_ALL_TABLES' mode is set in SQLMode
 func (m SQLMode) HasStrictMode() bool {
 	return m&ModeStrictTransTables == ModeStrictTransTables || m&ModeStrictAllTables == ModeStrictAllTables

mysql/errcode.go

@@ -72,7 +72,7 @@ const (
 	ErrNonUniq                                                      = 1052
 	ErrServerShutdown                                               = 1053
 	ErrBadField                                                     = 1054
-	ErrWrongFieldWithGroup                                          = 1055
+	ErrFieldNotInGroupBy                                            = 1055
 	ErrWrongGroupField                                              = 1056
 	ErrWrongSumSelect                                               = 1057
 	ErrWrongValueCount                                              = 1058

mysql/errname.go

@@ -70,7 +70,7 @@ var MySQLErrName = map[uint16]string{
 	ErrNonUniq:                                  "Column '%-.192s' in %-.192s is ambiguous",
 	ErrServerShutdown:                           "Server shutdown in progress",
 	ErrBadField:                                 "Unknown column '%-.192s' in '%-.192s'",
-	ErrWrongFieldWithGroup:                      "'%-.192s' isn't in GROUP BY",
+	ErrFieldNotInGroupBy:                        "Expression #%d of SELECT list is not in GROUP BY clause and contains nonaggregated column '%s' which is not functionally dependent on columns in GROUP BY clause; this is incompatible with sql_mode=only_full_group_by",
 	ErrWrongGroupField:                          "Can't group on '%-.192s'",
 	ErrWrongSumSelect:                           "Statement has sum functions and columns in same statement",
 	ErrWrongValueCount:                          "Column count doesn't match value count",

mysql/state.go

@@ -38,7 +38,7 @@ var MySQLState = map[uint16]string{
 	ErrNonUniq:                             "23000",
 	ErrServerShutdown:                      "08S01",
 	ErrBadField:                            "42S22",
-	ErrWrongFieldWithGroup:                 "42000",
+	ErrFieldNotInGroupBy:                   "42000",
 	ErrWrongSumSelect:                      "42000",
 	ErrWrongGroupField:                     "42000",
 	ErrWrongValueCount:                     "21S01",