database: Introduce ColumnMap

`ColumnMap` provides a cached mapping of structs exported fields to
their database column names. By default, all exported struct fields are
mapped to their database column names using snake case notation. The `-`
(hyphen) directive for the db tag can be used to exclude certain fields.
Since `ColumnMap` uses cache, the returned slice MUST NOT be modified
directly.

Author: lippserd

database/column_map.go

@@ -0,0 +1,75 @@
+package database
+
+import (
+	"database/sql/driver"
+	"github.com/jmoiron/sqlx/reflectx"
+	"reflect"
+	"sync"
+)
+
+// ColumnMap provides a cached mapping of structs exported fields to their database column names.
+type ColumnMap interface {
+	// Columns returns database column names for a struct's exported fields in a cached manner.
+	// Thus, the returned slice MUST NOT be modified directly.
+	// By default, all exported struct fields are mapped to database column names using snake case notation.
+	// The - (hyphen) directive for the db tag can be used to exclude certain fields.
+	Columns(any) []string
+}
+
+// NewColumnMap returns a new ColumnMap.
+func NewColumnMap(mapper *reflectx.Mapper) ColumnMap {
+	return &columnMap{
+		cache:  make(map[reflect.Type][]string),
+		mapper: mapper,
+	}
+}
+
+type columnMap struct {
+	mutex  sync.Mutex
+	cache  map[reflect.Type][]string
+	mapper *reflectx.Mapper
+}
+
+func (m *columnMap) Columns(subject any) []string {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	t, ok := subject.(reflect.Type)
+	if !ok {
+		t = reflect.TypeOf(subject)
+	}
+
+	columns, ok := m.cache[t]
+	if !ok {
+		columns = m.getColumns(t)
+		m.cache[t] = columns
+	}
+
+	return columns
+}
+
+func (m *columnMap) getColumns(t reflect.Type) []string {
+	fields := m.mapper.TypeMap(t).Names
+	columns := make([]string, 0, len(fields))
+
+FieldLoop:
+	for _, f := range fields {
+		// If one of the parent fields implements the driver.Valuer interface, the field can be ignored.
+		for parent := f.Parent; parent != nil && parent.Zero.IsValid(); parent = parent.Parent {
+			// Check for pointer types.
+			if _, ok := reflect.New(parent.Field.Type).Interface().(driver.Valuer); ok {
+				continue FieldLoop
+			}
+			// Check for non-pointer types.
+			if _, ok := reflect.Zero(parent.Field.Type).Interface().(driver.Valuer); ok {
+				continue FieldLoop
+			}
+		}
+
+		columns = append(columns, f.Path)
+	}
+
+	// Shrink/reduce slice length and capacity:
+	// For a three-index slice (slice[a:b:c]), the length of the returned slice is b-a and the capacity is c-a.
+	return columns[0:len(columns):len(columns)]
+}

database/db.go

@@ -22,7 +22,6 @@ import (
 	"golang.org/x/sync/semaphore"
 	"net"
 	"net/url"
-	"reflect"
 	"strconv"
 	"strings"
 	"sync"
@@ -37,6 +36,7 @@ type DB struct {
 	Options *Options
 
 	addr              string
+	columnMap         ColumnMap
 	logger            *logging.Logger
 	tableSemaphores   map[string]*semaphore.Weighted
 	tableSemaphoresMu sync.Mutex
@@ -215,6 +215,7 @@ func NewDbFromConfig(c *Config, logger *logging.Logger, connectorCallbacks Retry
 	return &DB{
 		DB:              db,
 		Options:         &c.Options,
+		columnMap:       NewColumnMap(db.Mapper),
 		addr:            addr,
 		logger:          logger,
 		tableSemaphores: make(map[string]*semaphore.Weighted),
@@ -226,20 +227,6 @@ func (db *DB) GetAddr() string {
 	return db.addr
 }
 
-// BuildColumns returns all columns of the given struct.
-func (db *DB) BuildColumns(subject interface{}) []string {
-	fields := db.Mapper.TypeMap(reflect.TypeOf(subject)).Names
-	columns := make([]string, 0, len(fields))
-	for _, f := range fields {
-		if f.Field.Tag == "" {
-			continue
-		}
-		columns = append(columns, f.Name)
-	}
-
-	return columns
-}
-
 // BuildDeleteStmt returns a DELETE statement for the given struct.
 func (db *DB) BuildDeleteStmt(from interface{}) string {
 	return fmt.Sprintf(
@@ -250,7 +237,7 @@ func (db *DB) BuildDeleteStmt(from interface{}) string {
 
 // BuildInsertStmt returns an INSERT INTO statement for the given struct.
 func (db *DB) BuildInsertStmt(into interface{}) (string, int) {
-	columns := db.BuildColumns(into)
+	columns := db.columnMap.Columns(into)
 
 	return fmt.Sprintf(
 		`INSERT INTO "%s" ("%s") VALUES (%s)`,
@@ -264,7 +251,7 @@ func (db *DB) BuildInsertStmt(into interface{}) (string, int) {
 // which the database ignores rows that have already been inserted.
 func (db *DB) BuildInsertIgnoreStmt(into interface{}) (string, int) {
 	table := TableName(into)
-	columns := db.BuildColumns(into)
+	columns := db.columnMap.Columns(into)
 	var clause string
 
 	switch db.DriverName() {
@@ -289,7 +276,7 @@ func (db *DB) BuildInsertIgnoreStmt(into interface{}) (string, int) {
 func (db *DB) BuildSelectStmt(table interface{}, columns interface{}) string {
 	q := fmt.Sprintf(
 		`SELECT "%s" FROM "%s"`,
-		strings.Join(db.BuildColumns(columns), `", "`),
+		strings.Join(db.columnMap.Columns(columns), `", "`),
 		TableName(table),
 	)
 
@@ -303,7 +290,7 @@ func (db *DB) BuildSelectStmt(table interface{}, columns interface{}) string {
 
 // BuildUpdateStmt returns an UPDATE statement for the given struct.
 func (db *DB) BuildUpdateStmt(update interface{}) (string, int) {
-	columns := db.BuildColumns(update)
+	columns := db.columnMap.Columns(update)
 	set := make([]string, 0, len(columns))
 
 	for _, col := range columns {
@@ -319,12 +306,12 @@ func (db *DB) BuildUpdateStmt(update interface{}) (string, int) {
 
 // BuildUpsertStmt returns an upsert statement for the given struct.
 func (db *DB) BuildUpsertStmt(subject interface{}) (stmt string, placeholders int) {
-	insertColumns := db.BuildColumns(subject)
+	insertColumns := db.columnMap.Columns(subject)
 	table := TableName(subject)
 	var updateColumns []string
 
 	if upserter, ok := subject.(Upserter); ok {
-		updateColumns = db.BuildColumns(upserter.Upsert())
+		updateColumns = db.columnMap.Columns(upserter.Upsert())
 	} else {
 		updateColumns = insertColumns
 	}
@@ -358,7 +345,7 @@ func (db *DB) BuildUpsertStmt(subject interface{}) (stmt string, placeholders in
 // BuildWhere returns a WHERE clause with named placeholder conditions built from the specified struct
 // combined with the AND operator.
 func (db *DB) BuildWhere(subject interface{}) (string, int) {
-	columns := db.BuildColumns(subject)
+	columns := db.columnMap.Columns(subject)
 	where := make([]string, 0, len(columns))
 	for _, col := range columns {
 		where = append(where, fmt.Sprintf(`"%s" = :%s`, col, col))