The efficient way to convert struct to bson and bson to struct - mongodb

Question

What is the correct way to convert a struct to bson or bson to struct from the point of view of server performance?
bsonAsByte, err = bson.Marshal(&bsonData)
if err != nil {
panic(err)
}
err = bson.Unmarshal(bsonAsByte, &user)
if err != nil {
panic(err)
}

Answer 1

Most responses always use bson.Marshal() followed by bson.Unmarshal(), but this form is slower.
Imagine that you are on a server with thousands of accesses to the database per second. Your code can slow down server operation depending on the quality of the code.
For this reason, I always do the benchmark tests before choosing which method to use.
An example is shown below:
package bsontest
import (
"errors"
"fmt"
"go.mongodb.org/mongo-driver/bson"
"reflect"
"testing"
)
type User struct {
UniqueID string `bson:"_id"`
Name string `bson:"name"`
Password string `bson:"password"`
Email string `bson:"email"`
Age int `bson:"age"`
Admin bool `bson:"admin"`
}
func (e *User) FromBson(data bson.M) (err error) {
var tagValue string
element := reflect.ValueOf(e).Elem()
for i := 0; i < element.NumField(); i += 1 {
typeField := element.Type().Field(i)
tag := typeField.Tag
tagValue = tag.Get("bson")
if tagValue == "-" {
continue
}
switch element.Field(i).Kind() {
case reflect.String:
switch data[tagValue].(type) {
case string:
element.Field(i).SetString(data[tagValue].(string))
default:
err = errors.New(tagValue+" must be a string")
return
}
case reflect.Bool:
switch data[tagValue].(type) {
case bool:
element.Field(i).SetBool(data[tagValue].(bool))
default:
err = errors.New(tagValue+" must be a boolean")
return
}
case reflect.Int:
switch data[tagValue].(type) {
case int:
element.Field(i).SetInt(int64(data[tagValue].(int)))
case int64:
element.Field(i).SetInt(data[tagValue].(int64))
default:
err = errors.New(tagValue+" must be a integer")
return
}
}
}
return
}
func (e *User) ToBson() (data bson.M) {
var tagValue string
data = bson.M{}
element := reflect.ValueOf(e).Elem()
for i := 0; i < element.NumField(); i += 1 {
typeField := element.Type().Field(i)
tag := typeField.Tag
tagValue = tag.Get("bson")
if tagValue == "-" {
continue
}
switch element.Field(i).Kind() {
case reflect.String:
value := element.Field(i).String()
data[tagValue] = value
case reflect.Bool:
value := element.Field(i).Bool()
data[tagValue] = value
case reflect.Int:
value := element.Field(i).Int()
data[tagValue] = value
}
}
return
}
var user User
func init() {
user = User{
UniqueID: "12345-67890-ABCDE-FGHIJKL",
Name: "Fulano da Silva Sauro",
Password: "pangea",
Email: "sauro#pangea.com",
Admin: true,
}
}
func ExampleUser_ToBson() {
var err error
var userAsBSon = user.ToBson()
fmt.Printf("%+v\n", userAsBSon)
user = User{}
fmt.Printf("%+v\n", user)
err = user.FromBson(userAsBSon)
if err != nil {
panic(err)
}
fmt.Printf("%+v\n", user)
// Output:
// map[_id:12345-67890-ABCDE-FGHIJKL admin:true age:0 email:sauro#pangea.com name:Fulano da Silva Sauro password:pangea]
// {UniqueID: Name: Password: Email: Age:0 Admin:false}
// {UniqueID:12345-67890-ABCDE-FGHIJKL Name:Fulano da Silva Sauro Password:pangea Email:sauro#pangea.com Age:0 Admin:true}
}
func Benchmark_UsingMarshalAndUnmarshal(b *testing.B) {
var err error
var bsonAsByte []byte
var bsonData bson.M
for i := 0; i < b.N; i++ {
bsonAsByte, err = bson.Marshal(&user)
if err != nil {
panic(err)
}
err = bson.Unmarshal(bsonAsByte, &bsonData)
if err != nil {
panic(err)
}
}
}
func Benchmark_UsingUnmarshalAndMarshal(b *testing.B) {
var err error
var bsonAsByte []byte
var bsonData = bson.M{
"_id":"12345-67890-ABCDE-FGHIJKL",
"admin":true,
"age":0,
"email":"sauro#pangea.com",
"name":"Fulano da Silva Sauro",
"password":"pangea",
}
for i := 0; i < b.N; i++ {
bsonAsByte, err = bson.Marshal(&bsonData)
if err != nil {
panic(err)
}
err = bson.Unmarshal(bsonAsByte, &user)
if err != nil {
panic(err)
}
}
}
func Benchmark_UsingFromBson(b *testing.B) {
var err error
var bsonData = bson.M{
"_id":"12345-67890-ABCDE-FGHIJKL",
"admin":true,
"age":0,
"email":"sauro#pangea.com",
"name":"Fulano da Silva Sauro",
"password":"pangea",
}
for i := 0; i < b.N; i++ {
err = user.FromBson(bsonData)
if err != nil {
panic(err)
}
}
}
func Benchmark_UsingToBson(b *testing.B) {
var bsonData bson.M
for i := 0; i < b.N; i++ {
bsonData = user.ToBson()
}
_ = bsonData
}
Timers:
Benchmark_UsingMarshalAndUnmarshal
Benchmark_UsingMarshalAndUnmarshal-8 398800 2996 ns/op
Benchmark_UsingToBson
Benchmark_UsingToBson-8 1789176 643.0 ns/op
Benchmark_UsingFromBson
Benchmark_UsingFromBson-8 2128242 539.6 ns/op
Benchmark_UsingUnmarshalAndMarshal
Benchmark_UsingUnmarshalAndMarshal-8 474501 2524 ns/op