Skip to content

Commit 75586ff

Browse files
mattnibsmattnibs
authored
Get rid of unused error argument in aggfuncs.subst (#6375)
1 parent 1687efd commit 75586ff

File tree

2 files changed

+35
-124
lines changed

2 files changed

+35
-124
lines changed

‎compiler/semantic/projection.go‎

Lines changed: 32 additions & 117 deletions
Original file line numberDiff line numberDiff line change
@@ -51,11 +51,7 @@ func (p projection) aggCols() []column {
5151
func newColumn(name string, loc ast.Expr, e sem.Expr, funcs *aggfuncs) (*column, error) {
5252
c := &column{name: name, loc: loc}
5353
cnt := len(*funcs)
54-
var err error
55-
c.expr, err = funcs.subst(e)
56-
if err != nil {
57-
return nil, err
58-
}
54+
c.expr = funcs.subst(e)
5955
c.isAgg = cnt != len(*funcs)
6056
return c, nil
6157
}
@@ -76,169 +72,88 @@ func (a aggfuncs) tmp() string {
7672
return fmt.Sprintf("t%d", len(a))
7773
}
7874

79-
func (a *aggfuncs) subst(e sem.Expr) (sem.Expr, error) {
80-
var err error
75+
func (a *aggfuncs) subst(e sem.Expr) sem.Expr {
8176
switch e := e.(type) {
8277
case nil:
83-
return e, nil
78+
return e
8479
case *sem.AggFunc:
8580
// swap in a temp column for each agg function found, which
8681
// will then be referred to by the containing expression.
8782
// The agg function is computed into the tmp value with
8883
// the generated aggregate operator.
8984
tmp := a.tmp()
9085
*a = append(*a, namedAgg{name: tmp, agg: e})
91-
return sem.NewThis(e, []string{"in", tmp}), nil
86+
return sem.NewThis(e, []string{"in", tmp})
9287
case *sem.ArrayExpr:
93-
elems, err := a.substArrayElems(e.Elems)
94-
if err != nil {
95-
return nil, err
96-
}
97-
e.Elems = elems
88+
e.Elems = a.substArrayElems(e.Elems)
9889
case *sem.BinaryExpr:
99-
e.LHS, err = a.subst(e.LHS)
100-
if err != nil {
101-
return nil, err
102-
}
103-
e.RHS, err = a.subst(e.RHS)
104-
if err != nil {
105-
return nil, err
106-
}
90+
e.LHS = a.subst(e.LHS)
91+
e.RHS = a.subst(e.RHS)
10792
case *sem.CallExpr:
10893
for k, arg := range e.Args {
109-
e.Args[k], err = a.subst(arg)
110-
if err != nil {
111-
return nil, err
112-
}
94+
e.Args[k] = a.subst(arg)
11395
}
11496
case *sem.CondExpr:
115-
e.Cond, err = a.subst(e.Cond)
116-
if err != nil {
117-
return nil, err
118-
}
119-
e.Then, err = a.subst(e.Then)
120-
if err != nil {
121-
return nil, err
122-
}
123-
e.Else, err = a.subst(e.Else)
124-
if err != nil {
125-
return nil, err
126-
}
97+
e.Cond = a.subst(e.Cond)
98+
e.Then = a.subst(e.Then)
99+
e.Else = a.subst(e.Else)
127100
case *sem.DotExpr:
128-
e.LHS, err = a.subst(e.LHS)
129-
if err != nil {
130-
return nil, err
131-
}
101+
e.LHS = a.subst(e.LHS)
132102
case *sem.IndexExpr:
133-
e.Expr, err = a.subst(e.Expr)
134-
if err != nil {
135-
return nil, err
136-
}
137-
e.Index, err = a.subst(e.Index)
138-
if err != nil {
139-
return nil, err
140-
}
103+
e.Expr = a.subst(e.Expr)
104+
e.Index = a.subst(e.Index)
141105
case *sem.IsNullExpr:
142-
e.Expr, err = a.subst(e.Expr)
143-
if err != nil {
144-
return nil, err
145-
}
106+
e.Expr = a.subst(e.Expr)
146107
case *sem.LiteralExpr:
147108
case *sem.MapExpr:
148109
for _, ent := range e.Entries {
149-
ent.Key, err = a.subst(ent.Key)
150-
if err != nil {
151-
return nil, err
152-
}
153-
ent.Value, err = a.subst(ent.Value)
154-
if err != nil {
155-
return nil, err
156-
}
110+
ent.Key = a.subst(ent.Key)
111+
ent.Value = a.subst(ent.Value)
157112
}
158113
case *sem.RecordExpr:
159114
var elems []sem.RecordElem
160115
for _, elem := range e.Elems {
161116
switch elem := elem.(type) {
162117
case *sem.FieldElem:
163-
sub, err := a.subst(elem.Value)
164-
if err != nil {
165-
return nil, err
166-
}
118+
sub := a.subst(elem.Value)
167119
elems = append(elems, &sem.FieldElem{Node: elem, Name: elem.Name, Value: sub})
168120
case *sem.SpreadElem:
169-
sub, err := a.subst(elem.Expr)
170-
if err != nil {
171-
return nil, err
172-
}
173-
elems = append(elems, &sem.SpreadElem{Node: elem, Expr: sub})
121+
elems = append(elems, &sem.SpreadElem{Node: elem, Expr: a.subst(elem.Expr)})
174122
default:
175123
panic(elem)
176124
}
177125
}
178126
e.Elems = elems
179127
case *sem.RegexpMatchExpr:
180-
e.Expr, err = a.subst(e.Expr)
181-
if err != nil {
182-
return nil, err
183-
}
128+
e.Expr = a.subst(e.Expr)
184129
case *sem.RegexpSearchExpr:
185-
e.Expr, err = a.subst(e.Expr)
186-
if err != nil {
187-
return nil, err
188-
}
130+
e.Expr = a.subst(e.Expr)
189131
case *sem.SearchTermExpr:
190-
e.Expr, err = a.subst(e.Expr)
191-
if err != nil {
192-
return nil, err
193-
}
132+
e.Expr = a.subst(e.Expr)
194133
case *sem.SetExpr:
195-
elems, err := a.substArrayElems(e.Elems)
196-
if err != nil {
197-
return nil, err
198-
}
199-
e.Elems = elems
134+
e.Elems = a.substArrayElems(e.Elems)
200135
case *sem.SliceExpr:
201-
e.Expr, err = a.subst(e.Expr)
202-
if err != nil {
203-
return nil, err
204-
}
205-
e.From, err = a.subst(e.From)
206-
if err != nil {
207-
return nil, err
208-
}
209-
e.To, err = a.subst(e.To)
210-
if err != nil {
211-
return nil, err
212-
}
136+
e.Expr = a.subst(e.Expr)
137+
e.From = a.subst(e.From)
138+
e.To = a.subst(e.To)
213139
case *sem.ThisExpr:
214140
case *sem.UnaryExpr:
215-
e.Operand, err = a.subst(e.Operand)
216-
if err != nil {
217-
return nil, err
218-
}
141+
e.Operand = a.subst(e.Operand)
219142
}
220-
return e, nil
143+
return e
221144
}
222145

223-
func (a *aggfuncs) substArrayElems(elems []sem.ArrayElem) ([]sem.ArrayElem, error) {
146+
func (a *aggfuncs) substArrayElems(elems []sem.ArrayElem) []sem.ArrayElem {
224147
var out []sem.ArrayElem
225148
for _, e := range elems {
226149
switch e := e.(type) {
227150
case *sem.SpreadElem:
228-
sub, err := a.subst(e.Expr)
229-
if err != nil {
230-
return nil, err
231-
}
232-
out = append(out, &sem.SpreadElem{Node: e, Expr: sub})
151+
out = append(out, &sem.SpreadElem{Node: e, Expr: a.subst(e.Expr)})
233152
case *sem.ExprElem:
234-
sub, err := a.subst(e.Expr)
235-
if err != nil {
236-
return nil, err
237-
}
238-
out = append(out, &sem.ExprElem{Node: e, Expr: sub})
153+
out = append(out, &sem.ExprElem{Node: e, Expr: a.subst(e.Expr)})
239154
default:
240155
panic(e)
241156
}
242157
}
243-
return out, nil
158+
return out
244159
}

‎compiler/semantic/sql.go‎

Lines changed: 3 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -49,11 +49,7 @@ func (t *translator) sqlSelect(sel *ast.SQLSelect, seq sem.Seq) (sem.Seq, schema
4949
where = t.exprSchema(sch, sel.Where)
5050
}
5151
keyExprs := t.groupBy(sch, sel.GroupBy)
52-
having, err := t.having(sch, sel.Having, &funcs)
53-
if err != nil {
54-
t.error(sel.Having, err)
55-
return seq, badSchema()
56-
}
52+
having := t.having(sch, sel.Having, &funcs)
5753
// Now that all the pieces have been converted to sem tree fragments,
5854
// we stitch together the fragments into pipeline operators depending
5955
// on whether its an aggregation or a selection of scalar expressions.
@@ -72,9 +68,9 @@ func (t *translator) sqlSelect(sel *ast.SQLSelect, seq sem.Seq) (sem.Seq, schema
7268
return seq, sch
7369
}
7470

75-
func (t *translator) having(sch *selectSchema, e ast.Expr, funcs *aggfuncs) (sem.Expr, error) {
71+
func (t *translator) having(sch *selectSchema, e ast.Expr, funcs *aggfuncs) sem.Expr {
7672
if e == nil {
77-
return nil, nil
73+
return nil
7874
}
7975
return funcs.subst(t.exprSchema(&havingSchema{sch}, e))
8076
}

0 commit comments

Comments
 (0)