structs not supported

[egonelbre]

https://pkg.go.dev/cloud.google.com/go/spanner supports structs https://pkg.go.dev/cloud.google.com/go/spanner#hdr-Structs, however this feature is not exposed directly in go-sql-spanner.

For example the following code fails due to the check in

go-sql-spanner/driver.go

Line 748 in 94bc417

func checkIsValidType(v driver.Value) bool {

package main

import (
	"context"
	"database/sql"
	"fmt"

	_ "github.com/googleapis/go-sql-spanner"
	"github.com/googleapis/go-sql-spanner/examples"
)

func helloWorld(projectId, instanceId, databaseId string) error {
	ctx := context.Background()
	db, err := sql.Open("spanner", fmt.Sprintf("projects/%s/instances/%s/databases/%s", projectId, instanceId, databaseId))
	if err != nil {
		return fmt.Errorf("failed to open database connection: %v\n", err)
	}
	defer db.Close()

	type Entry struct {
		ID   int64
		Name string
	}

	entries := []Entry{
		{ID: 0, Name: "Hello"},
		{ID: 1, Name: "World"},
	}

	rows, err := db.QueryContext(ctx, "SELECT id, name FROM UNNEST(@entries)", entries)
	if err != nil {
		return fmt.Errorf("failed to execute query: %v", err)
	}
	defer rows.Close()

	for rows.Next() {
		var id int64
		var name string

		if err := rows.Scan(&id, &name); err != nil {
			return fmt.Errorf("failed to scan row values: %v", err)
		}
		fmt.Printf("%v %v\n", id, name)
	}
	if err := rows.Err(); err != nil {
		return fmt.Errorf("failed to execute query: %v", err)
	}
	return nil
}

func main() {
	examples.RunSampleOnEmulator(helloWorld)
}

If I change changeIsValidType to always return true, then the code above passes without problems.

There's probably a workaround for this, but I haven't, yet discovered it. Nevertheless, it would be nice to support struct and array of struct directly in go-sql-spanner.

[egonelbre]

It's not pretty, but a workaround is to use GenericColumnValue and construct it manually, like:

// the entries can be replaced with:
spanner.GenericColumnValue{
	Type: &spannerpb.Type{
		Code: spannerpb.TypeCode_ARRAY,
		ArrayElementType: &spannerpb.Type{
			Code: spannerpb.TypeCode_STRUCT,
			StructType: &spannerpb.StructType{
				Fields: []*spannerpb.StructType_Field{
					{Name: "id", Type: &spannerpb.Type{Code: spannerpb.TypeCode_INT64}},
					{Name: "name", Type: &spannerpb.Type{Code: spannerpb.TypeCode_STRING}},
				},
			},
		},
	},
	Value: &structpb.Value{
		Kind: &structpb.Value_ListValue{
			ListValue: &structpb.ListValue{
				Values: []*structpb.Value{
					{
						Kind: &structpb.Value_ListValue{
							ListValue: &structpb.ListValue{
								Values: []*structpb.Value{
									{Kind: &structpb.Value_StringValue{StringValue: "0"}},
									{Kind: &structpb.Value_StringValue{StringValue: "Hello"}},
								},
							},
						},
					},
					{
						Kind: &structpb.Value_ListValue{
							ListValue: &structpb.ListValue{
								Values: []*structpb.Value{
									{Kind: &structpb.Value_StringValue{StringValue: "1"}},
									{Kind: &structpb.Value_StringValue{StringValue: "World"}},
								},
							},
						},
					},
				},
			},
		},
	},
}

Of course, the readability can be significantly improved via some helpers, e.g.

// the entries can be replaced with:
spanner.GenericColumnValue{
	Type: arrayOf(
		structOf(
			fieldOf("id", int64Type()),
			fieldOf("name", stringType()),
		),
	)
	...
}

func arrayOf(typ *spannerpb.Type) *spannerpb.Type {
	return &spannerpb.Type{
		Code: spannerpb.TypeCode_ARRAY,
		ArrayElementType: typ,
	}
}

func structOf(fields ...*spannerpb.StructType_Field) *spannerpb.Type {
	return &spannerpb.Type{
		Code: spannerpb.TypeCode_Struct,
		Fields: fields,
	}
}

func fieldOf(name string, typ *spannerpb.Type) *spannerpb.StructType_Field {
	return &spannerpb.StructType_Field{
		Name: name,
		Type: typ,
	}
}

func int64Type() *spannerpb.Type { return &spannerpb.Type{Kind: spannerpb.TypeCoode_INT64} }
func stringType() *spannerpb.Type { return &spannerpb.Type{Kind: spannerpb.TypeCoode_STRING} }

[newtonmunene99]

#282 seems to break gorm custom datatypes(https://gorm.io/docs/data_types.html). My custom datatype valuer and scanner interfaces just seem to be getting ignored. Downgrading to v1.6.0 seems to work again.

Not sure if I'm missing something but here's my current implementation

type ColumnMetadata struct {
	TableName  string              `gorm:"primaryKey"`
	ColumnName string              `gorm:"primaryKey"`
	Metadata   *Metadata `gorm:"type:bytes"`
	CreatedAt  time.Time           // Automatically managed by GORM for creation time
	UpdatedAt  time.Time           // Automatically managed by GORM for update time
}

type Metadata struct {}

// Scan scans value into Metadata and implements sql.Scanner interface
func (c *Metadata) Scan(value interface{}) error {
	b, ok := value.([]byte)
	if !ok {
		return errors.New("type assertion to []byte failed")
	}
	return json.Unmarshal(b, &c)
}

// Value returns value of Metadata struct and implements driver.Valuer interface
func (c Metadata) Value() (driver.Value, error) {
	return json.Marshal(c)
}

func (c Metadata) GormDataType() string {
	return "bytes"
}

[egonelbre]

@newtonmunene99 ah didn't think about that interaction. Sent a patch #289