func (s *SelectStmt) checkOneColumn(ctx context.Context) error { // check select fields for _, f := range s.Fields { if err := expressions.CheckOneColumn(ctx, f.Expr); err != nil { return errors.Trace(err) } } // check group by if s.GroupBy != nil { for _, f := range s.GroupBy.By { if err := expressions.CheckOneColumn(ctx, f); err != nil { return errors.Trace(err) } } } // check order by if s.OrderBy != nil { for _, f := range s.OrderBy.By { if err := expressions.CheckOneColumn(ctx, f.Expr); err != nil { return errors.Trace(err) } } } // check having if s.Having != nil { if err := expressions.CheckOneColumn(ctx, s.Having.Expr); err != nil { return errors.Trace(err) } } return nil }
// CheckAndUpdateSelectList checks having fields validity and set hidden fields to selectList. func (r *HavingRset) CheckAndUpdateSelectList(selectList *plans.SelectList, groupBy []expression.Expression, tableFields []*field.ResultField) error { if err := expressions.CheckOneColumn(r.Expr); err != nil { return errors.Trace(err) } if expressions.ContainAggregateFunc(r.Expr) { expr, err := selectList.UpdateAggFields(r.Expr, tableFields) if err != nil { return errors.Errorf("%s in 'having clause'", err.Error()) } r.Expr = expr } else { // having can only contain group by column and select list, e.g, // `select c1 from t group by c2 having c3 > 0` is invalid, // because c3 is not in group by and select list. names := expressions.MentionedColumns(r.Expr) for _, name := range names { found := false // check name whether in select list. // notice that `select c1 as c2 from t group by c1, c2, c3 having c2 > c3`, // will use t.c2 not t.c1 here. if field.ContainFieldName(name, selectList.ResultFields, field.OrgFieldNameFlag) { continue } if field.ContainFieldName(name, selectList.ResultFields, field.FieldNameFlag) { if field.ContainFieldName(name, tableFields, field.OrgFieldNameFlag) { selectList.CloneHiddenField(name, tableFields) } continue } // check name whether in group by. // group by must only have column name, e.g, // `select c1 from t group by c2 having c2 > 0` is valid, // but `select c1 from t group by c2 + 1 having c2 > 0` is invalid. for _, by := range groupBy { if !field.CheckFieldsEqual(name, by.String()) { continue } // if name is not in table fields, it will get an unknown field error in GroupByRset, // so no need to check return value. selectList.CloneHiddenField(name, tableFields) found = true break } if !found { return errors.Errorf("Unknown column '%s' in 'having clause'", name) } } } return nil }
// CheckAndUpdateSelectList checks order by fields validity and set hidden fields to selectList. func (r *OrderByRset) CheckAndUpdateSelectList(selectList *plans.SelectList, tableFields []*field.ResultField) error { for i, v := range r.By { if err := expressions.CheckOneColumn(v.Expr); err != nil { return errors.Trace(err) } if expressions.ContainAggregateFunc(v.Expr) { expr, err := selectList.UpdateAggFields(v.Expr, tableFields) if err != nil { return errors.Errorf("%s in 'order clause'", err.Error()) } r.By[i].Expr = expr } else { names := expressions.MentionedColumns(v.Expr) for _, name := range names { // try to find in select list // TODO: mysql has confused result for this, see #555. // now we use select list then order by, later we should make it easier. if field.ContainFieldName(name, selectList.ResultFields, field.CheckFieldFlag) { // check ambiguous fields, like `select c1 as c2, c2 from t order by c2`. if err := field.CheckAmbiguousField(name, selectList.ResultFields, field.DefaultFieldFlag); err != nil { return errors.Errorf("Column '%s' in order statement is ambiguous", name) } continue } if !selectList.CloneHiddenField(name, tableFields) { return errors.Errorf("Unknown column '%s' in 'order clause'", name) } } } } return nil }
// ResolveSelectList gets fields and result fields from selectFields and srcFields, // including field validity check and wildcard field processing. func ResolveSelectList(selectFields []*field.Field, srcFields []*field.ResultField) (*SelectList, error) { selectList := &SelectList{ Fields: make([]*field.Field, 0, len(selectFields)), ResultFields: make([]*field.ResultField, 0, len(selectFields)), AggFields: make(map[int]struct{}), } wildcardNum := 0 for _, v := range selectFields { if err := expressions.CheckOneColumn(v.Expr); err != nil { return nil, errors.Trace(err) } // Check metioned field. names := expressions.MentionedColumns(v.Expr) if len(names) == 0 { selectList.AddField(v, nil) continue } // Check wildcard field. name := names[0] table, ok, err := field.CheckWildcardField(name) if err != nil { return nil, err } if ok { // Check unqualified wildcard field number, // like `select *, * from t`. if table == "" { wildcardNum++ if wildcardNum > 1 { return nil, errors.Errorf("wildcard field exist more than once") } } selectList.updateFields(table, srcFields) continue } var result *field.ResultField if err = field.CheckAllFieldNames(names, srcFields, field.DefaultFieldFlag); err != nil { return nil, errors.Trace(err) } if _, ok := v.Expr.(*expressions.Ident); ok { // Field is ident. if result, err = field.CloneFieldByName(name, srcFields, field.DefaultFieldFlag); err != nil { return nil, errors.Trace(err) } // Maybe alias name or only column name. if !expressions.IsQualified(v.Name) { result.Name = v.Name } } else { // The field is not an ident, maybe binary expression, // like `select c1 + c2`, or `select c1 + 10`, etc. result = &field.ResultField{Name: v.Name} } selectList.AddField(v, result) } selectList.HiddenFieldOffset = len(selectList.Fields) selectList.resolveAggFields() if selectList.HiddenFieldOffset == 0 { return nil, errors.Errorf("invalid empty select fields") } return selectList, nil }