go語言操作mongodb

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}})