Skip to content

Commit 336f728

Browse files
devanbenzdevanbenz
committed
fix: Do not panic when using an unexpected cursor type
This PR is used to alleviate the erroneous panic we are seeing corresponding with #26142. There should not be a panic and instead we should be throwing an error.
1 parent 769049b commit 336f728

File tree

3 files changed

+98
-62
lines changed

3 files changed

+98
-62
lines changed

‎storage/reads/array_cursor.gen.go‎

Lines changed: 56 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -24,101 +24,113 @@ const (
2424
MaxPointsPerBlock = 1000
2525
)
2626

27-
func newLimitArrayCursor(cur cursors.Cursor) cursors.Cursor {
27+
func newLimitArrayCursor(cur cursors.Cursor) (cursors.Cursor, error) {
2828
switch cur := cur.(type) {
2929

3030
case cursors.FloatArrayCursor:
31-
return newFloatLimitArrayCursor(cur)
31+
return newFloatLimitArrayCursor(cur), nil
3232

3333
case cursors.IntegerArrayCursor:
34-
return newIntegerLimitArrayCursor(cur)
34+
return newIntegerLimitArrayCursor(cur), nil
3535

3636
case cursors.UnsignedArrayCursor:
37-
return newUnsignedLimitArrayCursor(cur)
37+
return newUnsignedLimitArrayCursor(cur), nil
3838

3939
case cursors.StringArrayCursor:
40-
return newStringLimitArrayCursor(cur)
40+
return newStringLimitArrayCursor(cur), nil
4141

4242
case cursors.BooleanArrayCursor:
43-
return newBooleanLimitArrayCursor(cur)
43+
return newBooleanLimitArrayCursor(cur), nil
4444

4545
default:
46-
panic(fmt.Sprintf("unreachable: %T", cur))
46+
return nil, &errors2.Error{
47+
Code: errors2.EInvalid,
48+
Msg: fmt.Sprintf("unreachable: %s", arrayCursorType(cur)),
49+
}
4750
}
4851
}
4952

50-
func newWindowFirstArrayCursor(cur cursors.Cursor, window interval.Window) cursors.Cursor {
53+
func newWindowFirstArrayCursor(cur cursors.Cursor, window interval.Window) (cursors.Cursor, error) {
5154
if window.IsZero() {
5255
return newLimitArrayCursor(cur)
5356
}
5457
switch cur := cur.(type) {
5558

5659
case cursors.FloatArrayCursor:
57-
return newFloatWindowFirstArrayCursor(cur, window)
60+
return newFloatWindowFirstArrayCursor(cur, window), nil
5861

5962
case cursors.IntegerArrayCursor:
60-
return newIntegerWindowFirstArrayCursor(cur, window)
63+
return newIntegerWindowFirstArrayCursor(cur, window), nil
6164

6265
case cursors.UnsignedArrayCursor:
63-
return newUnsignedWindowFirstArrayCursor(cur, window)
66+
return newUnsignedWindowFirstArrayCursor(cur, window), nil
6467

6568
case cursors.StringArrayCursor:
66-
return newStringWindowFirstArrayCursor(cur, window)
69+
return newStringWindowFirstArrayCursor(cur, window), nil
6770

6871
case cursors.BooleanArrayCursor:
69-
return newBooleanWindowFirstArrayCursor(cur, window)
72+
return newBooleanWindowFirstArrayCursor(cur, window), nil
7073

7174
default:
72-
panic(fmt.Sprintf("unreachable: %T", cur))
75+
return nil, &errors2.Error{
76+
Code: errors2.EInvalid,
77+
Msg: fmt.Sprintf("unreachable: %s", arrayCursorType(cur)),
78+
}
7379
}
7480
}
7581

76-
func newWindowLastArrayCursor(cur cursors.Cursor, window interval.Window) cursors.Cursor {
82+
func newWindowLastArrayCursor(cur cursors.Cursor, window interval.Window) (cursors.Cursor, error) {
7783
if window.IsZero() {
7884
return newLimitArrayCursor(cur)
7985
}
8086
switch cur := cur.(type) {
8187

8288
case cursors.FloatArrayCursor:
83-
return newFloatWindowLastArrayCursor(cur, window)
89+
return newFloatWindowLastArrayCursor(cur, window), nil
8490

8591
case cursors.IntegerArrayCursor:
86-
return newIntegerWindowLastArrayCursor(cur, window)
92+
return newIntegerWindowLastArrayCursor(cur, window), nil
8793

8894
case cursors.UnsignedArrayCursor:
89-
return newUnsignedWindowLastArrayCursor(cur, window)
95+
return newUnsignedWindowLastArrayCursor(cur, window), nil
9096

9197
case cursors.StringArrayCursor:
92-
return newStringWindowLastArrayCursor(cur, window)
98+
return newStringWindowLastArrayCursor(cur, window), nil
9399

94100
case cursors.BooleanArrayCursor:
95-
return newBooleanWindowLastArrayCursor(cur, window)
101+
return newBooleanWindowLastArrayCursor(cur, window), nil
96102

97103
default:
98-
panic(fmt.Sprintf("unreachable: %T", cur))
104+
return nil, &errors2.Error{
105+
Code: errors2.EInvalid,
106+
Msg: fmt.Sprintf("unreachable: %s", arrayCursorType(cur)),
107+
}
99108
}
100109
}
101110

102-
func newWindowCountArrayCursor(cur cursors.Cursor, window interval.Window) cursors.Cursor {
111+
func newWindowCountArrayCursor(cur cursors.Cursor, window interval.Window) (cursors.Cursor, error) {
103112
switch cur := cur.(type) {
104113

105114
case cursors.FloatArrayCursor:
106-
return newFloatWindowCountArrayCursor(cur, window)
115+
return newFloatWindowCountArrayCursor(cur, window), nil
107116

108117
case cursors.IntegerArrayCursor:
109-
return newIntegerWindowCountArrayCursor(cur, window)
118+
return newIntegerWindowCountArrayCursor(cur, window), nil
110119

111120
case cursors.UnsignedArrayCursor:
112-
return newUnsignedWindowCountArrayCursor(cur, window)
121+
return newUnsignedWindowCountArrayCursor(cur, window), nil
113122

114123
case cursors.StringArrayCursor:
115-
return newStringWindowCountArrayCursor(cur, window)
124+
return newStringWindowCountArrayCursor(cur, window), nil
116125

117126
case cursors.BooleanArrayCursor:
118-
return newBooleanWindowCountArrayCursor(cur, window)
127+
return newBooleanWindowCountArrayCursor(cur, window), nil
119128

120129
default:
121-
panic(fmt.Sprintf("unreachable: %T", cur))
130+
return nil, &errors2.Error{
131+
Code: errors2.EInvalid,
132+
Msg: fmt.Sprintf("unreachable: %s", arrayCursorType(cur)),
133+
}
122134
}
123135
}
124136

@@ -142,37 +154,43 @@ func newWindowSumArrayCursor(cur cursors.Cursor, window interval.Window) (cursor
142154
}
143155
}
144156

145-
func newWindowMinArrayCursor(cur cursors.Cursor, window interval.Window) cursors.Cursor {
157+
func newWindowMinArrayCursor(cur cursors.Cursor, window interval.Window) (cursors.Cursor, error) {
146158
switch cur := cur.(type) {
147159

148160
case cursors.FloatArrayCursor:
149-
return newFloatWindowMinArrayCursor(cur, window)
161+
return newFloatWindowMinArrayCursor(cur, window), nil
150162

151163
case cursors.IntegerArrayCursor:
152-
return newIntegerWindowMinArrayCursor(cur, window)
164+
return newIntegerWindowMinArrayCursor(cur, window), nil
153165

154166
case cursors.UnsignedArrayCursor:
155-
return newUnsignedWindowMinArrayCursor(cur, window)
167+
return newUnsignedWindowMinArrayCursor(cur, window), nil
156168

157169
default:
158-
panic(fmt.Sprintf("unsupported for aggregate min: %T", cur))
170+
return nil, &errors2.Error{
171+
Code: errors2.EInvalid,
172+
Msg: fmt.Sprintf("unsupported for aggregate min: %s", arrayCursorType(cur)),
173+
}
159174
}
160175
}
161176

162-
func newWindowMaxArrayCursor(cur cursors.Cursor, window interval.Window) cursors.Cursor {
177+
func newWindowMaxArrayCursor(cur cursors.Cursor, window interval.Window) (cursors.Cursor, error) {
163178
switch cur := cur.(type) {
164179

165180
case cursors.FloatArrayCursor:
166-
return newFloatWindowMaxArrayCursor(cur, window)
181+
return newFloatWindowMaxArrayCursor(cur, window), nil
167182

168183
case cursors.IntegerArrayCursor:
169-
return newIntegerWindowMaxArrayCursor(cur, window)
184+
return newIntegerWindowMaxArrayCursor(cur, window), nil
170185

171186
case cursors.UnsignedArrayCursor:
172-
return newUnsignedWindowMaxArrayCursor(cur, window)
187+
return newUnsignedWindowMaxArrayCursor(cur, window), nil
173188

174189
default:
175-
panic(fmt.Sprintf("unsupported for aggregate max: %T", cur))
190+
return nil, &errors2.Error{
191+
Code: errors2.EInvalid,
192+
Msg: fmt.Sprintf("unsupported for aggregate max: %s", arrayCursorType(cur)),
193+
}
176194
}
177195
}
178196

‎storage/reads/array_cursor.gen.go.tmpl‎

Lines changed: 36 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -18,53 +18,65 @@ const (
1818
MaxPointsPerBlock = 1000
1919
)
2020

21-
func newLimitArrayCursor(cur cursors.Cursor) cursors.Cursor {
21+
func newLimitArrayCursor(cur cursors.Cursor) (cursors.Cursor, error) {
2222
switch cur := cur.(type) {
2323
{{range .}}{{/* every type supports limit */}}
2424
case cursors.{{.Name}}ArrayCursor:
25-
return new{{.Name}}LimitArrayCursor(cur)
25+
return new{{.Name}}LimitArrayCursor(cur), nil
2626
{{end}}
2727
default:
28-
panic(fmt.Sprintf("unreachable: %T", cur))
28+
return nil, &errors2.Error{
29+
Code: errors2.EInvalid,
30+
Msg: fmt.Sprintf("unreachable: %s", arrayCursorType(cur)),
31+
}
2932
}
3033
}
3134

32-
func newWindowFirstArrayCursor(cur cursors.Cursor, window interval.Window) cursors.Cursor {
35+
func newWindowFirstArrayCursor(cur cursors.Cursor, window interval.Window) (cursors.Cursor, error) {
3336
if window.IsZero() {
3437
return newLimitArrayCursor(cur)
3538
}
3639
switch cur := cur.(type) {
3740
{{range .}}{{/* every type supports first */}}
3841
case cursors.{{.Name}}ArrayCursor:
39-
return new{{.Name}}WindowFirstArrayCursor(cur, window)
42+
return new{{.Name}}WindowFirstArrayCursor(cur, window), nil
4043
{{end}}
4144
default:
42-
panic(fmt.Sprintf("unreachable: %T", cur))
45+
return nil, &errors2.Error{
46+
Code: errors2.EInvalid,
47+
Msg: fmt.Sprintf("unreachable: %s", arrayCursorType(cur)),
48+
}
4349
}
4450
}
4551

46-
func newWindowLastArrayCursor(cur cursors.Cursor, window interval.Window) cursors.Cursor {
52+
func newWindowLastArrayCursor(cur cursors.Cursor, window interval.Window) (cursors.Cursor, error) {
4753
if window.IsZero() {
4854
return newLimitArrayCursor(cur)
4955
}
5056
switch cur := cur.(type) {
5157
{{range .}}{{/* every type supports last */}}
5258
case cursors.{{.Name}}ArrayCursor:
53-
return new{{.Name}}WindowLastArrayCursor(cur, window)
59+
return new{{.Name}}WindowLastArrayCursor(cur, window), nil
5460
{{end}}
5561
default:
56-
panic(fmt.Sprintf("unreachable: %T", cur))
62+
return nil, &errors2.Error{
63+
Code: errors2.EInvalid,
64+
Msg: fmt.Sprintf("unreachable: %s", arrayCursorType(cur)),
65+
}
5766
}
5867
}
5968

60-
func newWindowCountArrayCursor(cur cursors.Cursor, window interval.Window) cursors.Cursor {
69+
func newWindowCountArrayCursor(cur cursors.Cursor, window interval.Window) (cursors.Cursor, error) {
6170
switch cur := cur.(type) {
6271
{{range .}}{{/* every type supports count */}}
6372
case cursors.{{.Name}}ArrayCursor:
64-
return new{{.Name}}WindowCountArrayCursor(cur, window)
73+
return new{{.Name}}WindowCountArrayCursor(cur, window), nil
6574
{{end}}
6675
default:
67-
panic(fmt.Sprintf("unreachable: %T", cur))
76+
return nil, &errors2.Error{
77+
Code: errors2.EInvalid,
78+
Msg: fmt.Sprintf("unreachable: %s", arrayCursorType(cur)),
79+
}
6880
}
6981
}
7082

@@ -87,35 +99,41 @@ func newWindowSumArrayCursor(cur cursors.Cursor, window interval.Window) (cursor
8799
}
88100
}
89101

90-
func newWindowMinArrayCursor(cur cursors.Cursor, window interval.Window) cursors.Cursor {
102+
func newWindowMinArrayCursor(cur cursors.Cursor, window interval.Window) (cursors.Cursor, error) {
91103
switch cur := cur.(type) {
92104
{{range .}}
93105
{{$Type := .Name}}
94106
{{range .Aggs}}
95107
{{if eq .Name "Min"}}
96108
case cursors.{{$Type}}ArrayCursor:
97-
return new{{$Type}}WindowMinArrayCursor(cur, window)
109+
return new{{$Type}}WindowMinArrayCursor(cur, window), nil
98110
{{end}}
99111
{{end}}{{/* for each supported agg fn */}}
100112
{{end}}{{/* for each field type */}}
101113
default:
102-
panic(fmt.Sprintf("unsupported for aggregate min: %T", cur))
114+
return nil, &errors2.Error{
115+
Code: errors2.EInvalid,
116+
Msg: fmt.Sprintf("unsupported for aggregate min: %s", arrayCursorType(cur)),
117+
}
103118
}
104119
}
105120

106-
func newWindowMaxArrayCursor(cur cursors.Cursor, window interval.Window) cursors.Cursor {
121+
func newWindowMaxArrayCursor(cur cursors.Cursor, window interval.Window) (cursors.Cursor, error) {
107122
switch cur := cur.(type) {
108123
{{range .}}
109124
{{$Type := .Name}}
110125
{{range .Aggs}}
111126
{{if eq .Name "Max"}}
112127
case cursors.{{$Type}}ArrayCursor:
113-
return new{{$Type}}WindowMaxArrayCursor(cur, window)
128+
return new{{$Type}}WindowMaxArrayCursor(cur, window), nil
114129
{{end}}
115130
{{end}}{{/* for each supported agg fn */}}
116131
{{end}}{{/* for each field type */}}
117132
default:
118-
panic(fmt.Sprintf("unsupported for aggregate max: %T", cur))
133+
return nil, &errors2.Error{
134+
Code: errors2.EInvalid,
135+
Msg: fmt.Sprintf("unsupported for aggregate max: %s", arrayCursorType(cur)),
136+
}
119137
}
120138
}
121139

‎storage/reads/array_cursor.go‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ func (v *singleValue) Value(key string) (interface{}, bool) {
2020
func newAggregateArrayCursor(ctx context.Context, agg *datatypes.Aggregate, cursor cursors.Cursor) (cursors.Cursor, error) {
2121
switch agg.Type {
2222
case datatypes.Aggregate_AggregateTypeFirst, datatypes.Aggregate_AggregateTypeLast:
23-
return newLimitArrayCursor(cursor), nil
23+
return newLimitArrayCursor(cursor)
2424
}
2525
return newWindowAggregateArrayCursor(ctx, agg, interval.Window{}, cursor)
2626
}
@@ -32,17 +32,17 @@ func newWindowAggregateArrayCursor(ctx context.Context, agg *datatypes.Aggregate
3232

3333
switch agg.Type {
3434
case datatypes.Aggregate_AggregateTypeCount:
35-
return newWindowCountArrayCursor(cursor, window), nil
35+
return newWindowCountArrayCursor(cursor, window)
3636
case datatypes.Aggregate_AggregateTypeSum:
3737
return newWindowSumArrayCursor(cursor, window)
3838
case datatypes.Aggregate_AggregateTypeFirst:
39-
return newWindowFirstArrayCursor(cursor, window), nil
39+
return newWindowFirstArrayCursor(cursor, window)
4040
case datatypes.Aggregate_AggregateTypeLast:
41-
return newWindowLastArrayCursor(cursor, window), nil
41+
return newWindowLastArrayCursor(cursor, window)
4242
case datatypes.Aggregate_AggregateTypeMin:
43-
return newWindowMinArrayCursor(cursor, window), nil
43+
return newWindowMinArrayCursor(cursor, window)
4444
case datatypes.Aggregate_AggregateTypeMax:
45-
return newWindowMaxArrayCursor(cursor, window), nil
45+
return newWindowMaxArrayCursor(cursor, window)
4646
case datatypes.Aggregate_AggregateTypeMean:
4747
return newWindowMeanArrayCursor(cursor, window)
4848
default:

0 commit comments

Comments
 (0)