How to define a custom type? about pg HOT 8 CLOSED

type MyObject struct {
    Id bson.ObjectId
}

package main

import (
    "fmt"

    "gopkg.in/mgo.v2/bson"
    "gopkg.in/pg.v4"
)

type User struct {
    Id     bson.ObjectId `sql:",pk"`
    Name   string
    Emails []string
}

func (u User) String() string {
    return fmt.Sprintf("User<%d %s %v>", u.Id.Hex(), u.Name, u.Emails)
}

func createSchema(db *pg.DB) error {
    queries := []string{
        `CREATE TABLE users (id bit(96), name text, emails jsonb)`,
    }
    for _, q := range queries {
        _, err := db.Exec(q)
        if err != nil {
            return err
        }
    }
    return nil
}

func main() {
    db := pg.Connect(&pg.Options{
        User:     "postgres",
        Password: "xxx",
    })

    err := createSchema(db)
    if err != nil {
        panic(err)
    }

    var id = bson.NewObjectId()
    fmt.Println(id, id.Hex())

    user1 := &User{
        Id:     id,
        Name:   "admin",
        Emails: []string{"admin1@admin", "admin2@admin"},
    }
    err = db.Create(user1)
    if err != nil {
        panic(err)
    }
}

package main

import (
    "fmt"

    "github.com/m4rw3r/uuid"
    "gopkg.in/pg.v4"
)

type User struct {
    Id     uuid.UUID
    Name   string
    Emails []string
}

func (u User) String() string {
    return fmt.Sprintf("User<%s %s %v>", u.Id, u.Name, u.Emails)
}

func createSchema(db *pg.DB) error {
    queries := []string{
        `CREATE EXTENSION IF NOT EXISTS "uuid-ossp"`,
        `DROP TABLE users`,
        `CREATE TABLE users (id uuid, name text, emails jsonb)`,
    }
    for _, q := range queries {
        _, err := db.Exec(q)
        if err != nil {
            return err
        }
    }
    return nil
}

func main() {
    db := pg.Connect(&pg.Options{
        User:     "postgres",
        Password: "",
    })

    err := createSchema(db)
    if err != nil {
        panic(err)
    }

    id, err := uuid.V4()
    if err != nil {
        panic(err)
    }

    user1 := &User{
        Id:     id,
        Name:   "admin",
        Emails: []string{"admin1@admin", "admin2@admin"},
    }
    err = db.Create(user1)
    if err != nil {
        panic(err)
    }
    fmt.Println(user1)
}

type MyObjectId struct {
    V bson.ObjectId
}

func (id MyObjectId) String() string {
    return id.V.Hex()
}

func (id *MyObjectId) Scan(val interface{}) error {
    if b, ok := val.([]byte); ok {
        id.V = bson.ObjectId(b)
        return nil
    }
    return errors.New("MyObjectId Scan(): invalid data")
}

func (id MyObjectId) Value() (driver.Value, error) {
    b := []byte(id.V)
    return b, nil
}

type User struct {
    Id     MyObjectId
    Name   string
    Emails []string
}