08b131c5ee
Performance is comparable to sting.ToLower BenchmarkSnakeCase-4 200000 5922 ns/op 1216 B/op 97 allocs/op BenchmarkToLower-4 300000 5418 ns/op 704 B/op 74 allocs/op
95 lines
2.7 KiB
Go
95 lines
2.7 KiB
Go
package gocqlx
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"reflect"
|
|
|
|
"github.com/gocql/gocql"
|
|
"github.com/jmoiron/sqlx/reflectx"
|
|
)
|
|
|
|
// structOnlyError returns an error appropriate for type when a non-scannable
|
|
// struct is expected but something else is given
|
|
func structOnlyError(t reflect.Type) error {
|
|
isStruct := t.Kind() == reflect.Struct
|
|
isScanner := reflect.PtrTo(t).Implements(_unmarshallerInterface)
|
|
if !isStruct {
|
|
return fmt.Errorf("expected %s but got %s", reflect.Struct, t.Kind())
|
|
}
|
|
if isScanner {
|
|
return fmt.Errorf("structscan expects a struct dest but the provided struct type %s implements unmarshaler", t.Name())
|
|
}
|
|
return fmt.Errorf("expected a struct, but struct %s has no exported fields", t.Name())
|
|
}
|
|
|
|
// reflect helpers
|
|
|
|
var _unmarshallerInterface = reflect.TypeOf((*gocql.Unmarshaler)(nil)).Elem()
|
|
|
|
func baseType(t reflect.Type, expected reflect.Kind) (reflect.Type, error) {
|
|
t = reflectx.Deref(t)
|
|
if t.Kind() != expected {
|
|
return nil, fmt.Errorf("expected %s but got %s", expected, t.Kind())
|
|
}
|
|
return t, nil
|
|
}
|
|
|
|
// isScannable takes the reflect.Type and the actual dest value and returns
|
|
// whether or not it's Scannable. Something is scannable if:
|
|
// * it is not a struct
|
|
// * it implements gocql.Unmarshaler
|
|
// * it has no exported fields
|
|
func isScannable(t reflect.Type) bool {
|
|
if reflect.PtrTo(t).Implements(_unmarshallerInterface) {
|
|
return true
|
|
}
|
|
if t.Kind() != reflect.Struct {
|
|
return true
|
|
}
|
|
|
|
// it's not important that we use the right mapper for this particular object,
|
|
// we're only concerned on how many exported fields this struct has
|
|
m := DefaultMapper
|
|
if len(m.TypeMap(t).Index) == 0 {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// fieldsByName fills a values interface with fields from the passed value based
|
|
// on the traversals in int. If ptrs is true, return addresses instead of values.
|
|
// We write this instead of using FieldsByName to save allocations and map lookups
|
|
// when iterating over many rows. Empty traversals will get an interface pointer.
|
|
// Because of the necessity of requesting ptrs or values, it's considered a bit too
|
|
// specialized for inclusion in reflectx itself.
|
|
func fieldsByTraversal(v reflect.Value, traversals [][]int, values []interface{}, ptrs bool) error {
|
|
v = reflect.Indirect(v)
|
|
if v.Kind() != reflect.Struct {
|
|
return errors.New("argument not a struct")
|
|
}
|
|
|
|
for i, traversal := range traversals {
|
|
if len(traversal) == 0 {
|
|
values[i] = new(interface{})
|
|
continue
|
|
}
|
|
f := reflectx.FieldByIndexes(v, traversal)
|
|
if ptrs {
|
|
values[i] = f.Addr().Interface()
|
|
} else {
|
|
values[i] = f.Interface()
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func missingFields(transversals [][]int) (field int, err error) {
|
|
for i, t := range transversals {
|
|
if len(t) == 0 {
|
|
return i, errors.New("missing field")
|
|
}
|
|
}
|
|
return 0, nil
|
|
}
|