renamed SelectedExprs to projectedDeps (SelectedExprs weren't actually the selected exprs)

Author: angelamayxie

sql/analyzer/replace_count_star.go

@@ -40,8 +40,8 @@ func replaceCountStar(ctx *sql.Context, a *Analyzer, n sql.Node, _ *plan.Scope,
 				qFlags.Set(sql.QFlagMax1Row)
 			}
 
-			if len(agg.SelectedExprs) == 1 && len(agg.GroupByExprs) == 0 {
-				child := agg.SelectedExprs[0]
+			if len(agg.ProjectedExprs()) == 1 && len(agg.GroupByExprs) == 0 {
+				child := agg.ProjectedExprs()[0]
 				var cnt *aggregation.Count
 				name := ""
 				if alias, ok := child.(*expression.Alias); ok {

sql/analyzer/replace_sort.go

@@ -201,7 +201,7 @@ func replaceAgg(ctx *sql.Context, a *Analyzer, node sql.Node, scope *plan.Scope,
 			return n, transform.SameTree, nil
 		}
 		// TODO: optimize when there are multiple aggregations; use LATERAL JOINS
-		if len(gb.SelectedExprs) != 1 || len(gb.GroupByExprs) != 0 {
+		if len(gb.ProjectedExprs()) != 1 || len(gb.GroupByExprs) != 0 {
 			return n, transform.SameTree, nil
 		}
 
@@ -237,7 +237,7 @@ func replaceAgg(ctx *sql.Context, a *Analyzer, node sql.Node, scope *plan.Scope,
 
 		// generate sort fields from aggregations
 		var sf sql.SortField
-		switch agg := gb.SelectedExprs[0].(type) {
+		switch agg := gb.ProjectedExprs()[0].(type) {
 		case *aggregation.Max:
 			gf, ok := agg.UnaryExpression.Child.(*expression.GetField)
 			if !ok {
@@ -268,7 +268,7 @@ func replaceAgg(ctx *sql.Context, a *Analyzer, node sql.Node, scope *plan.Scope,
 		}
 
 		// replace all aggs in proj.Projections with GetField
-		name := gb.SelectedExprs[0].String()
+		name := gb.ProjectedExprs()[0].String()
 		newProjs, _, err := transform.Exprs(proj.Projections, func(e sql.Expression) (sql.Expression, transform.TreeIdentity, error) {
 			if strings.EqualFold(e.String(), name) {
 				return sf.Column, transform.NewTree, nil

sql/analyzer/resolve_ctes.go

@@ -35,7 +35,7 @@ func schemaLength(node sql.Node) int {
 			schemaLen = len(node.Projections)
 			return false
 		case *plan.GroupBy:
-			schemaLen = len(node.SelectedExprs)
+			schemaLen = len(node.ProjectedExprs())
 			return false
 		case *plan.Window:
 			schemaLen = len(node.SelectExprs)

sql/analyzer/unnest_insubqueries.go

@@ -306,7 +306,7 @@ func getHighestProjection(n sql.Node) (sql.Expression, bool, error) {
 			// todo(max): could make better effort to get column ids from these,
 			// but real fix is also giving synthesized projection column ids
 			// in binder
-			proj = nn.SelectedExprs
+			proj = nn.ProjectedExprs()
 		case *plan.Window:
 			proj = nn.SelectExprs
 		case *plan.SetOp:

sql/analyzer/validation_rules.go

@@ -251,34 +251,50 @@ func validateGroupBy(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scop
 	var err error
 	//var parent sql.Node
 	transform.Inspect(n, func(n sql.Node) bool {
-		//defer func() {
-		//	parent = n
-		//}()
+		/*defer func() {
+			parent = n
+		}()*/
 
 		gb, ok := n.(*plan.GroupBy)
 		if !ok {
 			return true
 		}
 
-		//switch parent.(type) {
-		//case *plan.Having, *plan.Project, *plan.Sort:
-		//	// TODO: these shouldn't be skipped; you can group by primary key without problem b/c only one value
-		//	// https://dev.mysql.com/doc/refman/8.0/en/group-by-handling.html#:~:text=The%20query%20is%20valid%20if%20name%20is%20a%20primary%20key
-		//	return true
-		//}
+		/*switch parent.(type) {
+		case *plan.Having, *plan.Project, *plan.Sort:
+			// TODO: these shouldn't be skipped; you can group by primary key without problem b/c only one value
+			// https://dev.mysql.com/doc/refman/8.0/en/group-by-handling.html#:~:text=The%20query%20is%20valid%20if%20name%20is%20a%20primary%20key
+			return true
+		} */
 
 		// Allow the parser use the GroupBy node to eval the aggregation functions
 		// for sql statements that don't make use of the GROUP BY expression.
 		if len(gb.GroupByExprs) == 0 {
 			return true
 		}
 
+		primaryKeys := make(map[string]bool)
+		for _, col := range gb.Child.Schema() {
+			if col.PrimaryKey {
+				primaryKeys[strings.ToLower(col.Name)] = true
+			}
+		}
+
 		var groupBys []string
+		groupByPrimaryKeys := 0
 		for _, expr := range gb.GroupByExprs {
 			groupBys = append(groupBys, expr.String())
+			if primaryKeys[strings.ToLower(expr.String())] {
+				groupByPrimaryKeys++
+			}
+
+		}
+
+		if len(primaryKeys) != 0 && groupByPrimaryKeys == len(primaryKeys) {
+			return true
 		}
 
-		for _, expr := range gb.SelectedExprs {
+		for _, expr := range gb.ProjectedExprs() {
 			if _, ok := expr.(sql.Aggregation); !ok {
 				if !expressionReferencesOnlyGroupBys(groupBys, expr) {
 					err = analyzererrors.ErrValidationGroupBy.New(expr.String())

sql/plan/group_by.go

@@ -30,7 +30,7 @@ var ErrGroupBy = errors.NewKind("group by aggregation '%v' not supported")
 // GroupBy groups the rows by some expressions.
 type GroupBy struct {
 	UnaryNode
-	SelectedExprs []sql.Expression
+	projectedDeps []sql.Expression
 	GroupByExprs  []sql.Expression
 }
 
@@ -46,15 +46,15 @@ var _ sql.CollationCoercible = (*GroupBy)(nil)
 func NewGroupBy(selectedExprs, groupByExprs []sql.Expression, child sql.Node) *GroupBy {
 	return &GroupBy{
 		UnaryNode:     UnaryNode{Child: child},
-		SelectedExprs: selectedExprs,
+		projectedDeps: selectedExprs,
 		GroupByExprs:  groupByExprs,
 	}
 }
 
 // Resolved implements the Resolvable interface.
 func (g *GroupBy) Resolved() bool {
 	return g.UnaryNode.Child.Resolved() &&
-		expression.ExpressionsResolved(g.SelectedExprs...) &&
+		expression.ExpressionsResolved(g.projectedDeps...) &&
 		expression.ExpressionsResolved(g.GroupByExprs...)
 }
 
@@ -64,8 +64,8 @@ func (g *GroupBy) IsReadOnly() bool {
 
 // Schema implements the Node interface.
 func (g *GroupBy) Schema() sql.Schema {
-	var s = make(sql.Schema, len(g.SelectedExprs))
-	for i, e := range g.SelectedExprs {
+	var s = make(sql.Schema, len(g.projectedDeps))
+	for i, e := range g.projectedDeps {
 		var name string
 		if n, ok := e.(sql.Nameable); ok {
 			name = n.Name()
@@ -101,7 +101,7 @@ func (g *GroupBy) WithChildren(children ...sql.Node) (sql.Node, error) {
 		return nil, sql.ErrInvalidChildrenNumber.New(g, len(children), 1)
 	}
 
-	return NewGroupBy(g.SelectedExprs, g.GroupByExprs, children[0]), nil
+	return NewGroupBy(g.projectedDeps, g.GroupByExprs, children[0]), nil
 }
 
 // CollationCoercibility implements the interface sql.CollationCoercible.
@@ -111,16 +111,16 @@ func (g *GroupBy) CollationCoercibility(ctx *sql.Context) (collation sql.Collati
 
 // WithExpressions implements the Node interface.
 func (g *GroupBy) WithExpressions(exprs ...sql.Expression) (sql.Node, error) {
-	expected := len(g.SelectedExprs) + len(g.GroupByExprs)
+	expected := len(g.projectedDeps) + len(g.GroupByExprs)
 	if len(exprs) != expected {
 		return nil, sql.ErrInvalidChildrenNumber.New(g, len(exprs), expected)
 	}
 
-	agg := make([]sql.Expression, len(g.SelectedExprs))
-	copy(agg, exprs[:len(g.SelectedExprs)])
+	agg := make([]sql.Expression, len(g.projectedDeps))
+	copy(agg, exprs[:len(g.projectedDeps)])
 
 	grouping := make([]sql.Expression, len(g.GroupByExprs))
-	copy(grouping, exprs[len(g.SelectedExprs):])
+	copy(grouping, exprs[len(g.projectedDeps):])
 
 	return NewGroupBy(agg, grouping, g.Child), nil
 }
@@ -129,8 +129,8 @@ func (g *GroupBy) String() string {
 	pr := sql.NewTreePrinter()
 	_ = pr.WriteNode("GroupBy")
 
-	var selectedExprs = make([]string, len(g.SelectedExprs))
-	for i, e := range g.SelectedExprs {
+	var selectedExprs = make([]string, len(g.projectedDeps))
+	for i, e := range g.projectedDeps {
 		selectedExprs[i] = e.String()
 	}
 
@@ -151,8 +151,8 @@ func (g *GroupBy) DebugString() string {
 	pr := sql.NewTreePrinter()
 	_ = pr.WriteNode("GroupBy")
 
-	var selectedExprs = make([]string, len(g.SelectedExprs))
-	for i, e := range g.SelectedExprs {
+	var selectedExprs = make([]string, len(g.projectedDeps))
+	for i, e := range g.projectedDeps {
 		selectedExprs[i] = sql.DebugString(e)
 	}
 
@@ -172,12 +172,12 @@ func (g *GroupBy) DebugString() string {
 // Expressions implements the Expressioner interface.
 func (g *GroupBy) Expressions() []sql.Expression {
 	var exprs []sql.Expression
-	exprs = append(exprs, g.SelectedExprs...)
+	exprs = append(exprs, g.projectedDeps...)
 	exprs = append(exprs, g.GroupByExprs...)
 	return exprs
 }
 
 // ProjectedExprs implements the sql.Projector interface
 func (g *GroupBy) ProjectedExprs() []sql.Expression {
-	return g.SelectedExprs
+	return g.projectedDeps
 }

sql/rowexec/rel.go

@@ -394,7 +394,7 @@ func (b *BaseBuilder) buildSet(ctx *sql.Context, n *plan.Set, row sql.Row) (sql.
 func (b *BaseBuilder) buildGroupBy(ctx *sql.Context, n *plan.GroupBy, row sql.Row) (sql.RowIter, error) {
 	span, ctx := ctx.Span("plan.GroupBy", trace.WithAttributes(
 		attribute.Int("groupings", len(n.GroupByExprs)),
-		attribute.Int("aggregates", len(n.SelectedExprs)),
+		attribute.Int("aggregates", len(n.ProjectedExprs())),
 	))
 
 	i, err := b.buildNodeExec(ctx, n.Child, row)
@@ -405,9 +405,9 @@ func (b *BaseBuilder) buildGroupBy(ctx *sql.Context, n *plan.GroupBy, row sql.Ro
 
 	var iter sql.RowIter
 	if len(n.GroupByExprs) == 0 {
-		iter = newGroupByIter(n.SelectedExprs, i)
+		iter = newGroupByIter(n.ProjectedExprs(), i)
 	} else {
-		iter = newGroupByGroupingIter(ctx, n.SelectedExprs, n.GroupByExprs, i)
+		iter = newGroupByGroupingIter(ctx, n.ProjectedExprs(), n.GroupByExprs, i)
 	}
 
 	return sql.NewSpanIter(span, iter), nil