chore(engine): Make literals simple types

Signed-off-by: Christian Haudum <christian.haudum@gmail.com>

Author: chaudum

pkg/engine/engine_test.go

@@ -55,8 +55,8 @@ func createRecord(t *testing.T, schema *arrow.Schema, data [][]interface{}) arro
 }
 
 func TestConvertArrowRecordsToLokiResult(t *testing.T) {
-	mdTypeLabel := datatype.ColumnMetadata(types.ColumnTypeLabel, datatype.String)
-	mdTypeMetadata := datatype.ColumnMetadata(types.ColumnTypeMetadata, datatype.String)
+	mdTypeLabel := datatype.ColumnMetadata(types.ColumnTypeLabel, datatype.Loki.String)
+	mdTypeMetadata := datatype.ColumnMetadata(types.ColumnTypeMetadata, datatype.Loki.String)
 
 	t.Run("rows without log line, timestamp, or labels are ignored", func(t *testing.T) {
 		schema := arrow.NewSchema(

pkg/engine/executor/dataobjscan.go

@@ -468,15 +468,15 @@ func schemaFromColumns(columns []physical.ColumnExpression) (*arrow.Schema, erro
 			// so we don't always explode out to the full set of columns.
 			addField(arrow.Field{
 				Name:     columnExpr.Ref.Column,
-				Type:     arrow.BinaryTypes.String,
+				Type:     datatype.Arrow.String,
 				Nullable: true,
-				Metadata: datatype.ColumnMetadata(types.ColumnTypeLabel, datatype.String),
+				Metadata: datatype.ColumnMetadata(types.ColumnTypeLabel, datatype.Loki.String),
 			})
 			addField(arrow.Field{
 				Name:     columnExpr.Ref.Column,
-				Type:     arrow.BinaryTypes.String,
+				Type:     datatype.Arrow.String,
 				Nullable: true,
-				Metadata: datatype.ColumnMetadata(types.ColumnTypeMetadata, datatype.String),
+				Metadata: datatype.ColumnMetadata(types.ColumnTypeMetadata, datatype.Loki.String),
 			})
 
 		case types.ColumnTypeParsed, types.ColumnTypeGenerated:
@@ -499,7 +499,7 @@ func arrowTypeFromColumnRef(ref types.ColumnRef) (arrow.DataType, arrow.Metadata
 		}
 	}
 
-	return arrow.BinaryTypes.String, datatype.ColumnMetadata(ref.Type, datatype.String)
+	return datatype.Arrow.String, datatype.ColumnMetadata(ref.Type, datatype.Loki.String)
 }
 
 // appendToBuilder appends a the provided field from record into the given

pkg/engine/executor/dataobjscan_predicate.go

@@ -175,7 +175,7 @@ func (m *timestampPredicateMapper) verify(expr physical.Expression) error {
 		if !okRHS {
 			return fmt.Errorf("invalid RHS for comparison: expected literal timestamp, got %T", binop.Right)
 		}
-		if rhsLit.ValueType() != datatype.Timestamp {
+		if rhsLit.ValueType() != datatype.Loki.Timestamp {
 			return fmt.Errorf("unsupported literal type for RHS: %s, expected timestamp", rhsLit.ValueType())
 		}
 		return nil
@@ -231,11 +231,12 @@ func (m *timestampPredicateMapper) rebound(op types.BinaryOp, rightExpr physical
 		return fmt.Errorf("internal error: rebound expected LiteralExpr, got %T for: %s", rightExpr, rightExpr.String())
 	}
 
-	if literalExpr.ValueType() != datatype.Timestamp {
+	if literalExpr.ValueType() != datatype.Loki.Timestamp {
 		// Also should be caught by verify.
 		return fmt.Errorf("internal error: unsupported literal type in rebound: %s, expected timestamp", literalExpr.ValueType())
 	}
-	val := literalExpr.Literal.(*datatype.TimestampLiteral).Value()
+	v := literalExpr.Literal.(datatype.TimestampLiteral).Value()
+	val := time.Unix(0, int64(v)).UTC()
 
 	switch op {
 	case types.BinaryOpEq: // ts == val
@@ -334,10 +335,10 @@ func mapMetadataPredicate(expr physical.Expression) (logs.RowPredicate, error) {
 			if !ok { // Should not happen
 				return nil, fmt.Errorf("RHS of EQ metadata predicate failed to cast to LiteralExpr")
 			}
-			if rightLiteral.ValueType() != datatype.String {
+			if rightLiteral.ValueType() != datatype.Loki.String {
 				return nil, fmt.Errorf("unsupported RHS literal type (%v) for EQ metadata predicate, expected ValueTypeStr", rightLiteral.ValueType())
 			}
-			val := rightLiteral.Literal.(*datatype.StringLiteral).Value()
+			val := rightLiteral.Literal.(datatype.StringLiteral).Value()
 
 			return logs.MetadataMatcherRowPredicate{
 				Key:   leftColumn.Ref.Column,
@@ -510,9 +511,9 @@ func rhsValue(e *physical.BinaryExpr) (string, error) {
 	if !ok { // Should not happen
 		return "", fmt.Errorf("RHS of %s message predicate failed to cast to LiteralExpr", op)
 	}
-	if rightLiteral.ValueType() != datatype.String {
+	if rightLiteral.ValueType() != datatype.Loki.String {
 		return "", fmt.Errorf("unsupported RHS literal type (%v) for %s message predicate, expected ValueTypeStr", rightLiteral.ValueType(), op)
 	}
 
-	return rightLiteral.Literal.(*datatype.StringLiteral).Value(), nil
+	return rightLiteral.Literal.(datatype.StringLiteral).Value(), nil
 }