Skip to content

armgit / fider

Public Imported from GitHub
0

Open platform to collect and prioritize feedback

3.0 KB
Raw Blame
package dbx

import (
	"database/sql"
	"fmt"
	"reflect"
	"sync"

	"github.com/lib/pq"
)

//RowMapper is responsible for mapping a sql.Rows into a Struct (model)
type RowMapper struct {
	cache map[reflect.Type]TypeMapper
	sync.RWMutex
}

//NewRowMapper creates a new instance of RowMapper
func NewRowMapper() *RowMapper {
	return &RowMapper{
		cache: make(map[reflect.Type]TypeMapper),
	}
}

//Map values from scanner (usually sql.Rows.Scan) into dest based on columns
func (m *RowMapper) Map(dest any, columns []string, scanner func(dest ...any) error) error {
	t := reflect.TypeOf(dest)
	if t.Kind() == reflect.Pointer {
		t = t.Elem()
	}

	var (
		typeMapper TypeMapper
		ok         bool
	)

	m.RLock()
	typeMapper, ok = m.cache[t]
	m.RUnlock()

	if !ok {
		typeMapper = NewTypeMapper(t)
		m.Lock()
		m.cache[t] = typeMapper
		m.Unlock()
	}

	pointers := make([]any, len(columns))
	for i, c := range columns {
		mapping := typeMapper.Fields[c]
		field := reflect.ValueOf(dest).Elem()

		for _, f := range mapping.FieldName {
			if field.Kind() == reflect.Pointer {
				if field.IsNil() {
					field.Set(reflect.New(field.Type().Elem()))
				}
				field = field.Elem()
			}
			field = field.FieldByName(f)
		}

		if !field.CanAddr() {
			panic(fmt.Sprintf("Field not found for column %s", c))
		}

		// Check if the field type implements sql.Scanner
		scannerType := reflect.TypeOf((*sql.Scanner)(nil)).Elem()
		implementsScanner := field.Addr().Type().Implements(scannerType)

		if field.Kind() == reflect.Slice && field.Type().Elem().Kind() != reflect.Uint8 && !implementsScanner {
			obj := reflect.New(reflect.MakeSlice(field.Type(), 0, 0).Type()).Elem()
			field.Set(obj)
			pointers[i] = pq.Array(field.Addr().Interface())
		} else {
			pointers[i] = field.Addr().Interface()
		}
	}

	return scanner(pointers...)
}

//TypeMapper holds information about how to map SQL ResultSet to a Struct
type TypeMapper struct {
	Type   reflect.Type
	Fields map[string]FieldInfo
}

//NewTypeMapper creates a new instance of TypeMapper for given reflect.Type
func NewTypeMapper(t reflect.Type) TypeMapper {
	all := make(map[string]FieldInfo)

	if t.Kind() != reflect.Struct {
		return TypeMapper{
			Type:   t,
			Fields: all,
		}
	}

	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		columnName := field.Tag.Get("db")
		if columnName != "" {
			fieldType := field.Type
			fieldKind := fieldType.Kind()

			if fieldKind == reflect.Pointer {
				fieldType = field.Type.Elem()
				mapper := NewTypeMapper(fieldType)
				for _, f := range mapper.Fields {
					all[columnName+"_"+f.ColumnName] = FieldInfo{
						ColumnName: columnName + "_" + f.ColumnName,
						FieldName:  append([]string{field.Name}, f.FieldName...),
					}
				}
			} else {
				all[columnName] = FieldInfo{
					FieldName:  []string{field.Name},
					ColumnName: columnName,
				}
			}
		}
	}
	return TypeMapper{
		Type:   t,
		Fields: all,
	}
}

//FieldInfo is a simple struct to map Column -> Field
type FieldInfo struct {
	FieldName  []string
	ColumnName string
}