Install the MongoDB Go Driver

The MongoDB Go Driver is made up of several packages. If you are just using go get, you can install the driver using:

go get github.com/mongodb/mongo-go-driver
// go get github.com/mongodb/mongo-go-driver/mongo

Example code

package main

import (
    "context"
    //"encoding/json"
    "fmt"
    "github.com/mongodb/mongo-go-driver/bson"
    "github.com/mongodb/mongo-go-driver/mongo"
    "github.com/mongodb/mongo-go-driver/mongo/options"
    "log"
    "time"
)

func main() {
    // 连接数据库
    ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)  // ctx
    opts := options.Client().ApplyURI("mongodb://localhost:27017")  // opts
    client, _ := mongo.Connect(ctx,opts)  // client

    // 使用
    db := client.Database("mark")  // database
    stu := db.Collection("student") // collection
    
    // 插入数据   直接使用student struct实例
    xm := Student{Name:"小明",Age:17,Sex:M,}
    res, _ := stu.InsertOne(ctx,xm)
    
    // 查询数据  bson.D{}创建查询条件
    cur, err := stu.Find(ctx, bson.D{})  // find   
    CheckError(err)
    
    // 延时关闭游标
    defer cur.Close(ctx)
    for cur.Next(ctx) {
    
        // 可以decode到bson.M  也就是一个map[string]interface{}中
        // 也可以直接decode到一个对象中
        s := &Student{}
        var result bson.M
        err := cur.Decode(&result) // decode 到map
        err = cur.Decode(s)  // decode 到对象
        CheckError(err)
        
        // do something with result....
        // 可以将map 或对象序列化为json
        //js ,_:=json.Marshal(result)
        //json.Unmarshal(js,s) //反学序列化回来
        fmt.Println(s)
    }


}


type Gender uint8
const (
    M = iota
    F
)

type Student struct {
    Name string `json:"name"`
    Age int `json:"age"`
    Sex Gender `json:"gender"`
}



func CheckError( err error){
    if err != nil {
        log.Println(err.Error())
        return
    }
}

Use BSON Objects in Go

JSON documents in MongoDB are stored in a binary representation called BSON (Binary-encoded JSON). Unlike other databases that store JSON data as simple strings and numbers, the BSON encoding extends the JSON representation to include additional types such as int, long, date, floating point, and decimal128. This makes it much easier for applications to reliably process, sort, and compare data. The Go Driver has two families of types for representing BSON data: The D types and the Raw types.

The D family of types is used to concisely build BSON objects using native Go types. This can be particularly useful for constructing commands passed to MongoDB. The D family consists of four types:

• D: A BSON document. This type should be used in situations where order matters, such as MongoDB commands.
• M: An unordered map. It is the same as D, except it does not preserve order.
• A: A BSON array.
• E: A single element inside a D.

Here is an example of a filter document built using D types which may be used to find documents where the name field matches either Alice or Bob:

bson.D{{
    "name", 
    bson.D{{
        "$in", 
        bson.A{"Alice", "Bob"}
    }}
}}

The Raw family of types is used for validating a slice of bytes. You can also retrieve single elements from Raw types using a Lookup(). This is useful if you don’t want the overhead of having to unmarshall the BSON into another type. This tutorial will just use the D family of types.

func main(){
    // bson.D 是一组key-value的集合  有序 
    d :=bson.D{
        {"Name","mark"},
        {"Age",12},
    }
    x :=d.Map() // 可以转为map
    fmt.Println(x)
    
    // bson.M是一个map 无序的key-value集合，在不要求顺序的情况下可以替代bson.D
    m :=bson.M{
        "name":"mark",
        "age":12,
    }
    fmt.Println(m)

    // bson.A 是一个数组
    a := bson.A{
        "jack","rose","jobs",
    }
    fmt.Println(a)

    // bson.E是只能包含一个key-value的map
    e :=bson.E{
        "name","mark",
    }
    fmt.Println(e)
}

Normal usages

Test connection is valid or not

    //pingerr :=client.Ping(ctx,nil)
    pingerr :=client.Ping(ctx,readpref.Primary())
    if pingerr != nil{
        fmt.Println(pingerr)
        return
    }

Get database or collection

c := client.Database("db_name").Collection("collection_name")

Drop collection

collection.Drop(ctx)

CRUD Operations

Insert Documents

insertOneRes, err := collection.InsertOne(ctx, data)
//InsertMany

Select Documents

// 查询单条数据
err := collection.FindOne(ctx, bson.D{{"name", "howie_2"}, {"age", 11}}).Decode(&obj)
// 查询单条数据后删除该数据
err = collection.FindOneAndDelete(ctx, bson.D{{"name", "howie_3"}})

// 询单条数据后修改该数据
err = collection.FindOneAndUpdate(ctx, bson.D{{"name", "howie_4"}}, bson.M{"$set": bson.M{"name": "这条数据我需要修改了"}})

// 查询单条数据后替换该数据
FindOneAndReplace(ctx, bson.D{{"name", "howie_5"}}, bson.M{"hero": "这条数据我替换了"})

// 一次查询多条数据(查询createtime>=3,限制取2条,createtime从大到小排序的数据)
cursor, err = collection.Find(ctx, bson.M{"createtime": bson.M{"$gte": 2}}, options.Find().SetLimit(2), options.Find().SetSort(bson.M{``"createtime"``: -1}))

// 查询数据数目
Count

Update Document

// 修改一条数据
updateRes, err ：= collection.UpdateOne(ctx, bson.M{``"name"``: ``"howie_2"``}, bson.M{``"$set"``: bson.M{``"name"``: ``"我要改了他的名字"``}})
// 修改多条数据
updateRes, err = collection.UpdateMany(ctx, bson.M{``"createtime"``: bson.M{``"$gte"``: 3}}, bson.M{``"$set"``: bson.M{``"name"``: ``"我要批量改了他的名字"``}})

Delete Documents

// 删除1条
delRes, err = collection.DeleteOne(ctx, bson.M{``"name"``: ``"howie_1"``})
// 删除多条
delRes, err = collection.DeleteMany(getContext(), bson.M{``"createtime"``: bson.M{``"$gte"``: 7}})