feat(spanner/spannertest): add support for bool parameter types

spanner/spannertest/db_eval.go

@@ -656,6 +656,7 @@ func compareVals(x, y interface{}) int {
 }
 
 var (
+	boolType    = spansql.Type{Base: spansql.Bool}
 	int64Type   = spansql.Type{Base: spansql.Int64}
 	float64Type = spansql.Type{Base: spansql.Float64}
 	stringType  = spansql.Type{Base: spansql.String}
@@ -664,6 +665,8 @@ var (
 func (ec evalContext) colInfo(e spansql.Expr) (colInfo, error) {
 	// TODO: more types
 	switch e := e.(type) {
+	case spansql.BoolLiteral:
+		return colInfo{Type: boolType}, nil
 	case spansql.IntegerLiteral:
 		return colInfo{Type: int64Type}, nil
 	case spansql.StringLiteral:

spanner/spannertest/db_test.go

@@ -526,6 +526,13 @@ func TestTableData(t *testing.T) {
 				{"Sam"},
 			},
 		},
+		{
+			`SELECT MAX(Name) FROM Staff WHERE Cool = @p1 LIMIT 1`,
+			queryParams{"p1": boolParam(true)},
+			[][]interface{}{
+				{"Teal'c"},
+			},
+		},
 		{
 			`SELECT MIN(Name) FROM Staff`,
 			nil,
@@ -874,6 +881,7 @@ func floatV(f float64) *structpb.Value                { return &structpb.Value{K
 func boolV(b bool) *structpb.Value                    { return &structpb.Value{Kind: &structpb.Value_BoolValue{b}} }
 func nullV() *structpb.Value                          { return &structpb.Value{Kind: &structpb.Value_NullValue{}} }
 
+func boolParam(b bool) queryParam     { return queryParam{Value: b, Type: boolType} }
 func stringParam(s string) queryParam { return queryParam{Value: s, Type: stringType} }
 func intParam(i int64) queryParam     { return queryParam{Value: i, Type: int64Type} }
 func floatParam(f float64) queryParam { return queryParam{Value: f, Type: float64Type} }

spanner/spannertest/inmem.go

@@ -748,6 +748,8 @@ func parseQueryParam(v *structpb.Value, typ *spannerpb.Type) (queryParam, error)
 		return queryParam{}, fmt.Errorf("unsupported well-known type value kind %T", v)
 	case *structpb.Value_NullValue:
 		return queryParam{Value: nil}, nil // TODO: set a type?
+	case *structpb.Value_BoolValue:
+		return queryParam{Value: v.BoolValue, Type: boolType}, nil
 	case *structpb.Value_NumberValue:
 		return queryParam{Value: v.NumberValue, Type: float64Type}, nil
 	case *structpb.Value_StringValue:

spanner/spannertest/integration_test.go

@@ -398,6 +398,55 @@ func TestIntegration_SpannerBasics(t *testing.T) {
 	if !reflect.DeepEqual(ages, wantAges) {
 		t.Errorf("Query with IN UNNEST gave wrong ages: got %+v, want %+v", ages, wantAges)
 	}
+
+	// Verify boolean query parameters
+	err = updateDDL(t, adminClient, `ALTER TABLE `+tableName+` ADD COLUMN SuperPower BOOL`)
+	if err != nil {
+		t.Fatalf("Adding new bool column: %v", err)
+	}
+	cts, err = client.Apply(ctx, []*spanner.Mutation{
+		// Set up super-power registry
+		spanner.Update(tableName,
+			[]string{"FirstName", "LastName", "SuperPower", "Updated"},
+			[]interface{}{"Tony", "Stark", false, spanner.CommitTimestamp}),
+		spanner.Update(tableName,
+			[]string{"FirstName", "LastName", "SuperPower", "Updated"},
+			[]interface{}{"Steve", "Rogers", true, spanner.CommitTimestamp}),
+		spanner.Update(tableName,
+			[]string{"FirstName", "LastName", "SuperPower", "Updated"},
+			[]interface{}{"Natasha", "Romanoff", false, spanner.CommitTimestamp}),
+		spanner.Update(tableName,
+			[]string{"FirstName", "LastName", "SuperPower", "Updated"},
+			[]interface{}{"Peter", "Quill", false, spanner.CommitTimestamp}),
+		spanner.Update(tableName,
+			[]string{"FirstName", "LastName", "SuperPower", "Updated"},
+			[]interface{}{"Peter", "Parker", true, spanner.CommitTimestamp}),
+	})
+	if err != nil {
+		t.Fatalf("Applying mutations: %v", err)
+	}
+
+	// Do a query to find the aliases of the two super-powered characters.
+	stmt = spanner.NewStatement(`SELECT Alias FROM ` + tableName + ` WHERE SuperPower = @p1 AND Alias IS NOT NULL`)
+	stmt.Params = map[string]interface{}{
+		"p1": true,
+	}
+	rows = client.Single().Query(ctx, stmt)
+	var registry []string
+	err = rows.Do(func(row *spanner.Row) error {
+		var alias string
+		if err := row.Columns(&alias); err != nil {
+			return err
+		}
+		registry = append(registry, alias)
+		return nil
+	})
+	if err != nil {
+		t.Fatalf("Iterating over query with boolean parameter: %v", err)
+	}
+	if want := []string{"Spider-Man", "Captain America"}; !reflect.DeepEqual(registry, want) {
+		t.Errorf("Query results = %v, want %v", registry, want)
+	}
 }
 
 func updateDDL(t *testing.T, adminClient *dbadmin.DatabaseAdminClient, statements ...string) error {