plan: prune cor cols in gby items.

plan/column_pruning.go

@@ -100,17 +100,34 @@ func (p *Aggregation) PruneColumns(parentUsedCols []*expression.Column) {
 			selfUsedCols = append(selfUsedCols, expression.ExtractColumns(arg)...)
 		}
 	}
-	for _, expr := range p.GroupByItems {
-		selfUsedCols = append(selfUsedCols, expression.ExtractColumns(expr)...)
+	if len(p.GroupByItems) > 0 {
+		for i := len(p.GroupByItems) - 1; i >= 0; i-- {
+			cols := expression.ExtractColumns(p.GroupByItems[i])
+			if len(cols) == 0 {
+				p.GroupByItems = append(p.GroupByItems[:i], p.GroupByItems[i+1:]...)
+			} else {
+				selfUsedCols = append(selfUsedCols, cols...)
+			}
+		}
+		// If all the group by items are pruned, we should add a constant 1 to keep the correctness.
+		// Because `select count(*) from t` is different from `select count(*) from t group by 1`.
+		if len(p.GroupByItems) == 0 {
+			p.GroupByItems = []expression.Expression{expression.One}
+		}
 	}
 	child.PruneColumns(selfUsedCols)
 }
 
 // PruneColumns implements LogicalPlan interface.
 func (p *Sort) PruneColumns(parentUsedCols []*expression.Column) {
 	child := p.children[0].(LogicalPlan)
-	for _, item := range p.ByItems {
-		parentUsedCols = append(parentUsedCols, expression.ExtractColumns(item.Expr)...)
+	for i := len(p.ByItems) - 1; i >= 0; i-- {
+		cols := expression.ExtractColumns(p.ByItems[i].Expr)
+		if len(cols) == 0 {
+			p.ByItems = append(p.ByItems[:i], p.ByItems[i+1:]...)
+		} else {
+			parentUsedCols = append(parentUsedCols, expression.ExtractColumns(p.ByItems[i].Expr)...)
+		}
 	}
 	child.PruneColumns(parentUsedCols)
 	p.SetSchema(p.children[0].Schema())

plan/logical_plan_test.go

@@ -512,6 +512,10 @@ func (s *testPlanSuite) TestPlanBuilder(c *C) {
 			sql:  "select count(c) ,(select count(s.b) from t s where s.a = t.a) from t",
 			plan: "Apply{DataScan(t)->Aggr(count(test.t.c),firstrow(test.t.a))->DataScan(s)->Selection->Aggr(count(s.b))}->Projection->Projection",
 		},
+		{
+			sql:  "select a from t where a in (select a from t s group by t.b)",
+			plan: "Join{DataScan(t)->DataScan(s)->Aggr(firstrow(s.a))->Projection}(test.t.a,a)->Projection",
+		},
 		{
 			// This will be resolved as in sub query.
 			sql:  "select * from t where 10 in (((select b from t s where s.a = t.a)))",
@@ -1060,6 +1064,13 @@ func (s *testPlanSuite) TestColumnPruning(c *C) {
 				"TableScan_2": {"c", "d"},
 			},
 		},
+		{
+			sql: "select a from t where a in (select a from t s group by t.b)",
+			ans: map[string][]string{
+				"TableScan_1": {"a"},
+				"TableScan_2": {"a"},
+			},
+		},
 	}
 	for _, ca := range cases {
 		comment := Commentf("for %s", ca.sql)

plan/physical_plan_builder.go

@@ -942,6 +942,9 @@ func (p *Sort) convert2PhysicalPlan(prop *requiredProperty) (*physicalPlanInfo,
 	if info != nil {
 		return info, nil
 	}
+	if len(p.ByItems) == 0 {
+		return p.children[0].(LogicalPlan).convert2PhysicalPlan(prop)
+	}
 	selfProp := &requiredProperty{
 		props: make([]*columnProp, 0, len(p.ByItems)),
 	}

plan/physical_plan_test.go

@@ -137,6 +137,12 @@ func (s *testPlanSuite) TestPushDownOrderbyAndLimit(c *C) {
 			orderByItmes: "[]",
 			limit:        "5",
 		},
+		{
+			sql:          "select * from t order by 1 limit 5",
+			best:         "Table(t)->Limit->Projection",
+			orderByItmes: "[]",
+			limit:        "5",
+		},
 		{
 			sql:          "select c from t order by c limit 5",
 			best:         "Index(t.c_d_e)[[<nil>,+inf]]->Limit->Projection",