Skip to content

Commit 12f98c6

Browse files
chaudumchaudum
committed
chore(engine): Make literals simple types
Signed-off-by: Christian Haudum <[email protected]>
1 parent 35bc47a commit 12f98c6

21 files changed

+287
-313
lines changed

‎pkg/engine/engine_test.go

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -55,8 +55,8 @@ func createRecord(t *testing.T, schema *arrow.Schema, data [][]interface{}) arro
5555
}
5656

5757
func TestConvertArrowRecordsToLokiResult(t *testing.T) {
58-
mdTypeLabel := datatype.ColumnMetadata(types.ColumnTypeLabel, datatype.String)
59-
mdTypeMetadata := datatype.ColumnMetadata(types.ColumnTypeMetadata, datatype.String)
58+
mdTypeLabel := datatype.ColumnMetadata(types.ColumnTypeLabel, datatype.LokiType.String)
59+
mdTypeMetadata := datatype.ColumnMetadata(types.ColumnTypeMetadata, datatype.LokiType.String)
6060

6161
t.Run("rows without log line, timestamp, or labels are ignored", func(t *testing.T) {
6262
schema := arrow.NewSchema(

‎pkg/engine/executor/dataobjscan_predicate.go

Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -135,7 +135,7 @@ func (m *timestampPredicateMapper) verify(expr physical.Expression) error {
135135
if !okRHS {
136136
return fmt.Errorf("invalid RHS for comparison: expected literal timestamp, got %T", binop.Right)
137137
}
138-
if rhsLit.ValueType() != datatype.Timestamp {
138+
if rhsLit.ValueType() != datatype.LokiType.Timestamp {
139139
return fmt.Errorf("unsupported literal type for RHS: %s, expected timestamp", rhsLit.ValueType())
140140
}
141141
return nil
@@ -191,11 +191,12 @@ func (m *timestampPredicateMapper) rebound(op types.BinaryOp, rightExpr physical
191191
return fmt.Errorf("internal error: rebound expected LiteralExpr, got %T for: %s", rightExpr, rightExpr.String())
192192
}
193193

194-
if literalExpr.ValueType() != datatype.Timestamp {
194+
if literalExpr.ValueType() != datatype.LokiType.Timestamp {
195195
// Also should be caught by verify.
196196
return fmt.Errorf("internal error: unsupported literal type in rebound: %s, expected timestamp", literalExpr.ValueType())
197197
}
198-
val := literalExpr.Literal.(*datatype.TimestampLiteral).Value()
198+
v := literalExpr.Literal.(datatype.TimestampLiteral).Value()
199+
val := time.Unix(0, int64(v)).UTC()
199200

200201
switch op {
201202
case types.BinaryOpEq: // ts == val
@@ -294,10 +295,10 @@ func mapMetadataPredicate(expr physical.Expression) (dataobj.LogsPredicate, erro
294295
if !ok { // Should not happen
295296
return nil, fmt.Errorf("RHS of EQ metadata predicate failed to cast to LiteralExpr")
296297
}
297-
if rightLiteral.ValueType() != datatype.String {
298+
if rightLiteral.ValueType() != datatype.LokiType.String {
298299
return nil, fmt.Errorf("unsupported RHS literal type (%v) for EQ metadata predicate, expected ValueTypeStr", rightLiteral.ValueType())
299300
}
300-
val := rightLiteral.Literal.(*datatype.StringLiteral).Value()
301+
val := rightLiteral.Literal.(datatype.StringLiteral).Value()
301302

302303
return dataobj.MetadataMatcherPredicate{
303304
Key: leftColumn.Ref.Column,

‎pkg/engine/executor/dataobjscan_predicate_test.go

Lines changed: 43 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@ import (
88
"github.com/stretchr/testify/require"
99

1010
"github.com/grafana/loki/v3/pkg/dataobj"
11+
"github.com/grafana/loki/v3/pkg/engine/internal/datatype"
1112
"github.com/grafana/loki/v3/pkg/engine/internal/types"
1213
"github.com/grafana/loki/v3/pkg/engine/planner/physical"
1314
)
@@ -30,6 +31,10 @@ func tsColExpr() *physical.ColumnExpr {
3031
return newColumnExpr(types.ColumnNameBuiltinTimestamp, types.ColumnTypeBuiltin)
3132
}
3233

34+
func ts(t time.Time) datatype.Timestamp {
35+
return datatype.Timestamp(t.UnixNano())
36+
}
37+
3338
func TestMapTimestampPredicate(t *testing.T) {
3439
time100 := time.Unix(0, 100).UTC()
3540
time200 := time.Unix(0, 200).UTC()
@@ -46,7 +51,7 @@ func TestMapTimestampPredicate(t *testing.T) {
4651
expr: &physical.BinaryExpr{
4752
Left: tsColExpr(),
4853
Op: types.BinaryOpEq,
49-
Right: physical.NewLiteral(time100),
54+
Right: physical.NewLiteral(ts(time100)),
5055
},
5156
want: dataobj.TimeRangePredicate[dataobj.LogsPredicate]{
5257
StartTime: time100,
@@ -60,7 +65,7 @@ func TestMapTimestampPredicate(t *testing.T) {
6065
expr: &physical.BinaryExpr{
6166
Left: tsColExpr(),
6267
Op: types.BinaryOpGt,
63-
Right: physical.NewLiteral(time100),
68+
Right: physical.NewLiteral(ts(time100)),
6469
},
6570
want: dataobj.TimeRangePredicate[dataobj.LogsPredicate]{
6671
StartTime: time100,
@@ -74,7 +79,7 @@ func TestMapTimestampPredicate(t *testing.T) {
7479
expr: &physical.BinaryExpr{
7580
Left: tsColExpr(),
7681
Op: types.BinaryOpGte,
77-
Right: physical.NewLiteral(time100),
82+
Right: physical.NewLiteral(ts(time100)),
7883
},
7984
want: dataobj.TimeRangePredicate[dataobj.LogsPredicate]{
8085
StartTime: time100,
@@ -88,7 +93,7 @@ func TestMapTimestampPredicate(t *testing.T) {
8893
expr: &physical.BinaryExpr{
8994
Left: tsColExpr(),
9095
Op: types.BinaryOpLt,
91-
Right: physical.NewLiteral(time100),
96+
Right: physical.NewLiteral(ts(time100)),
9297
},
9398
want: dataobj.TimeRangePredicate[dataobj.LogsPredicate]{
9499
StartTime: testOpenStart,
@@ -102,7 +107,7 @@ func TestMapTimestampPredicate(t *testing.T) {
102107
expr: &physical.BinaryExpr{
103108
Left: tsColExpr(),
104109
Op: types.BinaryOpLte,
105-
Right: physical.NewLiteral(time100),
110+
Right: physical.NewLiteral(ts(time100)),
106111
},
107112
want: dataobj.TimeRangePredicate[dataobj.LogsPredicate]{
108113
StartTime: testOpenStart,
@@ -119,7 +124,7 @@ func TestMapTimestampPredicate(t *testing.T) {
119124
Right: &physical.BinaryExpr{
120125
Left: tsColExpr(),
121126
Op: types.BinaryOpLt,
122-
Right: physical.NewLiteral(time100),
127+
Right: physical.NewLiteral(ts(time100)),
123128
},
124129
},
125130
errMatch: "invalid RHS for comparison: expected literal timestamp, got *physical.BinaryExpr",
@@ -135,23 +140,23 @@ func TestMapTimestampPredicate(t *testing.T) {
135140
Right: &physical.BinaryExpr{
136141
Left: tsColExpr(),
137142
Op: types.BinaryOpLte,
138-
Right: physical.NewLiteral(time200),
143+
Right: physical.NewLiteral(ts(time200)),
139144
},
140145
},
141146
},
142147
errMatch: "invalid RHS for comparison: expected literal timestamp, got *physical.BinaryExpr",
143148
},
144149
{
145150
desc: "input is not BinaryExpr",
146-
expr: physical.NewLiteral(time100),
151+
expr: physical.NewLiteral(ts(time100)),
147152
errMatch: "unsupported expression type for timestamp predicate: *physical.LiteralExpr, expected *physical.BinaryExpr",
148153
},
149154
{
150155
desc: "LHS of BinaryExpr is not ColumnExpr",
151156
expr: &physical.BinaryExpr{
152-
Left: physical.NewLiteral(time100),
157+
Left: physical.NewLiteral(ts(time100)),
153158
Op: types.BinaryOpEq,
154-
Right: physical.NewLiteral(time200),
159+
Right: physical.NewLiteral(ts(time200)),
155160
},
156161
errMatch: "invalid LHS for comparison: expected timestamp column, got 1970-01-01T00:00:00.0000001Z",
157162
},
@@ -160,7 +165,7 @@ func TestMapTimestampPredicate(t *testing.T) {
160165
expr: &physical.BinaryExpr{
161166
Left: newColumnExpr("other_col", types.ColumnTypeBuiltin),
162167
Op: types.BinaryOpEq,
163-
Right: physical.NewLiteral(time100),
168+
Right: physical.NewLiteral(ts(time100)),
164169
},
165170
errMatch: "invalid LHS for comparison: expected timestamp column, got builtin.other_col",
166171
},
@@ -187,7 +192,7 @@ func TestMapTimestampPredicate(t *testing.T) {
187192
expr: &physical.BinaryExpr{
188193
Left: tsColExpr(),
189194
Op: types.BinaryOpAnd,
190-
Right: physical.NewLiteral(time100),
195+
Right: physical.NewLiteral(ts(time100)),
191196
},
192197
errMatch: "invalid left operand for AND: unsupported expression type for timestamp predicate: *physical.ColumnExpr, expected *physical.BinaryExpr",
193198
},
@@ -199,7 +204,7 @@ func TestMapTimestampPredicate(t *testing.T) {
199204
Right: &physical.BinaryExpr{
200205
Left: tsColExpr(),
201206
Op: types.BinaryOpGt,
202-
Right: physical.NewLiteral(time100),
207+
Right: physical.NewLiteral(ts(time100)),
203208
},
204209
},
205210
errMatch: "unsupported operator for timestamp predicate: OR",
@@ -210,13 +215,13 @@ func TestMapTimestampPredicate(t *testing.T) {
210215
Left: &physical.BinaryExpr{
211216
Left: tsColExpr(),
212217
Op: types.BinaryOpGt,
213-
Right: physical.NewLiteral(time100),
218+
Right: physical.NewLiteral(ts(time100)),
214219
},
215220
Op: types.BinaryOpAnd,
216221
Right: &physical.BinaryExpr{
217222
Left: tsColExpr(),
218223
Op: types.BinaryOpLt,
219-
Right: physical.NewLiteral(time200),
224+
Right: physical.NewLiteral(ts(time200)),
220225
},
221226
},
222227
want: dataobj.TimeRangePredicate[dataobj.LogsPredicate]{
@@ -232,13 +237,13 @@ func TestMapTimestampPredicate(t *testing.T) {
232237
Left: &physical.BinaryExpr{
233238
Left: tsColExpr(),
234239
Op: types.BinaryOpGte,
235-
Right: physical.NewLiteral(time100),
240+
Right: physical.NewLiteral(ts(time100)),
236241
},
237242
Op: types.BinaryOpAnd,
238243
Right: &physical.BinaryExpr{
239244
Left: tsColExpr(),
240245
Op: types.BinaryOpLte,
241-
Right: physical.NewLiteral(time200),
246+
Right: physical.NewLiteral(ts(time200)),
242247
},
243248
},
244249
want: dataobj.TimeRangePredicate[dataobj.LogsPredicate]{
@@ -254,13 +259,13 @@ func TestMapTimestampPredicate(t *testing.T) {
254259
Left: &physical.BinaryExpr{
255260
Left: tsColExpr(),
256261
Op: types.BinaryOpGte,
257-
Right: physical.NewLiteral(time100),
262+
Right: physical.NewLiteral(ts(time100)),
258263
},
259264
Op: types.BinaryOpAnd,
260265
Right: &physical.BinaryExpr{
261266
Left: tsColExpr(),
262267
Op: types.BinaryOpLt,
263-
Right: physical.NewLiteral(time100),
268+
Right: physical.NewLiteral(ts(time100)),
264269
},
265270
},
266271
errMatch: "impossible time range: start_time (1970-01-01 00:00:00.0000001 +0000 UTC) equals end_time (1970-01-01 00:00:00.0000001 +0000 UTC) but the range is exclusive",
@@ -271,13 +276,13 @@ func TestMapTimestampPredicate(t *testing.T) {
271276
Left: &physical.BinaryExpr{
272277
Left: tsColExpr(),
273278
Op: types.BinaryOpGt,
274-
Right: physical.NewLiteral(time100),
279+
Right: physical.NewLiteral(ts(time100)),
275280
},
276281
Op: types.BinaryOpAnd,
277282
Right: &physical.BinaryExpr{
278283
Left: tsColExpr(),
279284
Op: types.BinaryOpLte,
280-
Right: physical.NewLiteral(time100),
285+
Right: physical.NewLiteral(ts(time100)),
281286
},
282287
},
283288
errMatch: "impossible time range: start_time (1970-01-01 00:00:00.0000001 +0000 UTC) equals end_time (1970-01-01 00:00:00.0000001 +0000 UTC) but the range is exclusive",
@@ -288,13 +293,13 @@ func TestMapTimestampPredicate(t *testing.T) {
288293
Left: &physical.BinaryExpr{
289294
Left: tsColExpr(),
290295
Op: types.BinaryOpGte,
291-
Right: physical.NewLiteral(time100),
296+
Right: physical.NewLiteral(ts(time100)),
292297
},
293298
Op: types.BinaryOpAnd,
294299
Right: &physical.BinaryExpr{
295300
Left: tsColExpr(),
296301
Op: types.BinaryOpLte,
297-
Right: physical.NewLiteral(time100),
302+
Right: physical.NewLiteral(ts(time100)),
298303
},
299304
},
300305
want: dataobj.TimeRangePredicate[dataobj.LogsPredicate]{
@@ -310,13 +315,13 @@ func TestMapTimestampPredicate(t *testing.T) {
310315
Left: &physical.BinaryExpr{
311316
Left: tsColExpr(),
312317
Op: types.BinaryOpEq,
313-
Right: physical.NewLiteral(time100),
318+
Right: physical.NewLiteral(ts(time100)),
314319
},
315320
Op: types.BinaryOpAnd,
316321
Right: &physical.BinaryExpr{
317322
Left: tsColExpr(),
318323
Op: types.BinaryOpEq,
319-
Right: physical.NewLiteral(time200),
324+
Right: physical.NewLiteral(ts(time200)),
320325
},
321326
},
322327
errMatch: "impossible time range: start_time (1970-01-01 00:00:00.0000002 +0000 UTC) is after end_time (1970-01-01 00:00:00.0000001 +0000 UTC)",
@@ -327,13 +332,13 @@ func TestMapTimestampPredicate(t *testing.T) {
327332
Left: &physical.BinaryExpr{
328333
Left: tsColExpr(),
329334
Op: types.BinaryOpLt,
330-
Right: physical.NewLiteral(time100),
335+
Right: physical.NewLiteral(ts(time100)),
331336
},
332337
Op: types.BinaryOpAnd,
333338
Right: &physical.BinaryExpr{
334339
Left: tsColExpr(),
335340
Op: types.BinaryOpGt,
336-
Right: physical.NewLiteral(time200),
341+
Right: physical.NewLiteral(ts(time200)),
337342
},
338343
},
339344
errMatch: "impossible time range: start_time (1970-01-01 00:00:00.0000002 +0000 UTC) is after end_time (1970-01-01 00:00:00.0000001 +0000 UTC)",
@@ -345,20 +350,20 @@ func TestMapTimestampPredicate(t *testing.T) {
345350
Left: &physical.BinaryExpr{
346351
Left: tsColExpr(),
347352
Op: types.BinaryOpGt,
348-
Right: physical.NewLiteral(time100),
353+
Right: physical.NewLiteral(ts(time100)),
349354
},
350355
Op: types.BinaryOpAnd,
351356
Right: &physical.BinaryExpr{
352357
Left: tsColExpr(),
353358
Op: types.BinaryOpLt,
354-
Right: physical.NewLiteral(time300),
359+
Right: physical.NewLiteral(ts(time300)),
355360
},
356361
},
357362
Op: types.BinaryOpAnd,
358363
Right: &physical.BinaryExpr{
359364
Left: tsColExpr(),
360365
Op: types.BinaryOpEq,
361-
Right: physical.NewLiteral(time200),
366+
Right: physical.NewLiteral(ts(time200)),
362367
},
363368
},
364369
want: dataobj.TimeRangePredicate[dataobj.LogsPredicate]{
@@ -374,13 +379,13 @@ func TestMapTimestampPredicate(t *testing.T) {
374379
Left: &physical.BinaryExpr{ // Invalid: LHS not timestamp column
375380
Left: newColumnExpr("not_ts", types.ColumnTypeBuiltin),
376381
Op: types.BinaryOpGt,
377-
Right: physical.NewLiteral(time100),
382+
Right: physical.NewLiteral(ts(time100)),
378383
},
379384
Op: types.BinaryOpAnd,
380385
Right: &physical.BinaryExpr{
381386
Left: tsColExpr(),
382387
Op: types.BinaryOpLt,
383-
Right: physical.NewLiteral(time200),
388+
Right: physical.NewLiteral(ts(time200)),
384389
},
385390
},
386391
errMatch: "invalid left operand for AND: invalid LHS for comparison: expected timestamp column, got builtin.not_ts",
@@ -391,7 +396,7 @@ func TestMapTimestampPredicate(t *testing.T) {
391396
Left: &physical.BinaryExpr{
392397
Left: tsColExpr(),
393398
Op: types.BinaryOpGt,
394-
Right: physical.NewLiteral(time100),
399+
Right: physical.NewLiteral(ts(time100)),
395400
},
396401
Op: types.BinaryOpAnd,
397402
Right: &physical.BinaryExpr{ // Invalid: RHS literal not timestamp
@@ -408,13 +413,13 @@ func TestMapTimestampPredicate(t *testing.T) {
408413
Left: &physical.BinaryExpr{
409414
Left: tsColExpr(),
410415
Op: types.BinaryOpLt,
411-
Right: physical.NewLiteral(time100),
416+
Right: physical.NewLiteral(ts(time100)),
412417
},
413418
Op: types.BinaryOpAnd,
414419
Right: &physical.BinaryExpr{
415420
Left: tsColExpr(),
416421
Op: types.BinaryOpLt,
417-
Right: physical.NewLiteral(time200),
422+
Right: physical.NewLiteral(ts(time200)),
418423
},
419424
},
420425
want: dataobj.TimeRangePredicate[dataobj.LogsPredicate]{
@@ -430,13 +435,13 @@ func TestMapTimestampPredicate(t *testing.T) {
430435
Left: &physical.BinaryExpr{
431436
Left: tsColExpr(),
432437
Op: types.BinaryOpLt,
433-
Right: physical.NewLiteral(time200),
438+
Right: physical.NewLiteral(ts(time200)),
434439
},
435440
Op: types.BinaryOpAnd,
436441
Right: &physical.BinaryExpr{
437442
Left: tsColExpr(),
438443
Op: types.BinaryOpLt,
439-
Right: physical.NewLiteral(time100),
444+
Right: physical.NewLiteral(ts(time100)),
440445
},
441446
},
442447
want: dataobj.TimeRangePredicate[dataobj.LogsPredicate]{
@@ -619,7 +624,7 @@ func TestMapMetadataPredicate(t *testing.T) {
619624
name: "error: RHS literal not string for EQ",
620625
expr: &physical.BinaryExpr{
621626
Left: &physical.ColumnExpr{Ref: types.ColumnRef{Column: "foo", Type: types.ColumnTypeMetadata}},
622-
Right: physical.NewLiteral(123), // Not string
627+
Right: physical.NewLiteral(int64(123)), // Not string
623628
Op: types.BinaryOpEq,
624629
},
625630
expectedPred: nil,

0 commit comments

Comments
 (0)