feat: add WithEnumsAsStrings transpiler option

Author: hugosandelius

spanfiltering/transpile.go

@@ -8,8 +8,11 @@ import (
 // TranspileFilter transpiles a parsed AIP filter expression to a spansql.BoolExpr, and
 // parameters used in the expression.
 // The parameter map is nil if the expression does not contain any parameters.
-func TranspileFilter(filter filtering.Filter) (spansql.BoolExpr, map[string]interface{}, error) {
+func TranspileFilter(
+	filter filtering.Filter,
+	options ...TranspileOption,
+) (spansql.BoolExpr, map[string]interface{}, error) {
 	var t Transpiler
-	t.Init(filter)
+	t.Init(filter, options...)
 	return t.Transpile()
 }

spanfiltering/transpile_test.go

@@ -18,6 +18,7 @@ func TestTranspileFilter(t *testing.T) {
 		expectedSQL    string
 		expectedParams map[string]interface{}
 		errorContains  string
+		options        []TranspileOption
 	}{
 		{
 			name:   "simple flag",
@@ -90,6 +91,19 @@ func TestTranspileFilter(t *testing.T) {
 			},
 		},
 
+		{
+			name:    "enum equality as strings",
+			options: []TranspileOption{WithEnumValuesAsStrings()},
+			filter:  `example_enum = ENUM_ONE`,
+			declarations: []filtering.DeclarationOption{
+				filtering.DeclareEnumIdent("example_enum", syntaxv1.Enum(0).Type()),
+			},
+			expectedSQL: `(example_enum = @param_0)`,
+			expectedParams: map[string]interface{}{
+				"param_0": "ENUM_ONE",
+			},
+		},
+
 		{
 			name:   "enum negated equality",
 			filter: `example_enum != ENUM_ONE`,
@@ -157,7 +171,7 @@ func TestTranspileFilter(t *testing.T) {
 				return
 			}
 			assert.NilError(t, err)
-			actual, params, err := TranspileFilter(filter)
+			actual, params, err := TranspileFilter(filter, tt.options...)
 			if err != nil && tt.errorContains != "" {
 				assert.ErrorContains(t, err, tt.errorContains)
 				return

spanfiltering/transpiler.go

@@ -17,13 +17,29 @@ type Transpiler struct {
 	filter       filtering.Filter
 	params       map[string]interface{}
 	paramCounter int
+	options      transpileOptions
 }
 
-func (t *Transpiler) Init(filter filtering.Filter) {
+type TranspileOption func(options *transpileOptions)
+
+func WithEnumValuesAsStrings() TranspileOption {
+	return func(options *transpileOptions) {
+		options.enumValuesAsStrings = true
+	}
+}
+
+type transpileOptions struct {
+	enumValuesAsStrings bool
+}
+
+func (t *Transpiler) Init(filter filtering.Filter, options ...TranspileOption) {
 	*t = Transpiler{
 		filter: filter,
 		params: make(map[string]interface{}),
 	}
+	for _, option := range options {
+		option(&t.options)
+	}
 }
 
 func (t *Transpiler) Transpile() (spansql.BoolExpr, map[string]interface{}, error) {
@@ -123,7 +139,9 @@ func (t *Transpiler) transpileIdentExpr(e *expr.Expr) (spansql.Expr, error) {
 	if messageType := identType.GetMessageType(); messageType != "" {
 		if enumType, err := protoregistry.GlobalTypes.FindEnumByName(protoreflect.FullName(messageType)); err == nil {
 			if enumValue := enumType.Descriptor().Values().ByName(protoreflect.Name(identExpr.GetName())); enumValue != nil {
-				// TODO: Configurable support for string literals.
+				if t.options.enumValuesAsStrings {
+					return t.param(string(enumValue.Name())), nil
+				}
 				// spanner does not support int32
 				return t.param(int64(enumValue.Number())), nil
 			}