The db.MapperFunc is not called properly

[luxiangqing]

Because different types of databases default return column name case inconsistency, oracle default uppercase, mysql default lowercase, I want to adapt to different databases struct field mapping, try using db.MapperFunc function in oracle can not work properly, StructScan return missing destination name error

var DB *sqlx.DB

func InitDB() {
    //db, err := sqlx.Connect("mysql", "xxxx")
    db, err := sqlx.Connect("godror", "xxxxx")
    if err != nil {
        panic(err)
    }
    DB = db
    DB.MapperFunc(DBMapper)
}

func DBMapper(s string) string {
    switch DB.DriverName() {
    case "mysql":
        return strings.ToLower(s)
    case "godror":
        return strings.ToUpper(s)
    case "sqlserver":
        return strings.ToLower(s)
    default:
        return strings.ToLower(s)
    }
}

type User struct {
    Id       int    `db:"id"`
    Username string `db:"username"`
    Nickname string `db:"nickname"`
    Password string `db:"password"`
    Phone    string `db:"phone"`
    Email    string `db:"email"`
}

func (u *User) ListByName(name string, db *sqlx.DB) (User, error) {
    query := "select * from tuser where username = ?"
    query = db.Rebind(query)
    var user User
    if err := db.QueryRowx(query, name).StructScan(&user); err != nil {
        return user, err
    }
    return user, nil
}

I checked the source code and found that when scanning the data into the structure filed, the parseName function call mapFunc not correctly, souce code as follows:

func parseName(field reflect.StructField, tagName string, mapFunc, tagMapFunc mapf) (tag, fieldName string) {
    // first, set the fieldName to the field's name
    fieldName = field.Name
    // if a mapFunc is set, use that to override the fieldName
    if mapFunc != nil {
        fieldName = mapFunc(fieldName)
    }

    // if there's no tag to look for, return the field name
    if tagName == "" {
        return "", fieldName
    }

    // if this tag is not set using the normal convention in the tag,
    // then return the fieldname..  this check is done because according
    // to the reflect documentation:
    //    If the tag does not have the conventional format,
    //    the value returned by Get is unspecified.
    // which doesn't sound great.
    if !strings.Contains(string(field.Tag), tagName+":") {
        return "", fieldName
    }

    // at this point we're fairly sure that we have a tag, so lets pull it out
    tag = field.Tag.Get(tagName)

    // if we have a mapper function, call it on the whole tag
    // XXX: this is a change from the old version, which pulled out the name
    // before the tagMapFunc could be run, but I think this is the right way
    if tagMapFunc != nil {
        tag = tagMapFunc(tag)
    }

    // finally, split the options from the name
    parts := strings.Split(tag, ",")
@   fieldName = parts[0]           //here mapFunc  is not called

    return tag, fieldName
}