go對mongodb的聚合查詢

mongodb的環境搭建參考前面一篇通過mongo-driver使用說明 GO 包管理機制

BSON 介紹

在Go中使用BSON對象構建操作命令

在我們發送查詢給數據庫之前， 很重要的一點是，理解Go Driver是如何和BSON對象協同工作的。

JSON文檔在MongoDB裏面以二進制形式存儲， 被稱作BSON（二進制編碼的JSON）。不像其他的數據庫保存JSON數據爲簡單的字符串和數字， BSON擴展了JSON的保存形式， 包括額外的類型， 比如int， long, date, floating point以及decimal128。這使得它讓應用程序更容易來可靠地處理、排序和比較數據。

Go Driver有兩個系列的類型表示BSON數據：D系列類型和Raw系列類型。

D系列的類型使用原生的Go類型簡單地構建BSON對象。這可以非常有用的來創建傳遞給MongoDB的命令。 D系列包含4種類型：
– D：一個BSON文檔。這個類型應該被用在順序很重要的場景， 比如MongoDB命令。
– M: 一個無需map。 它和D是一樣的， 除了它不保留順序。
– A: 一個BSON數組。
– E: 在D裏面的一個單一的子項。

這裏有一個使用D類型構建的過濾文檔的例子， 它可能被用在查詢name字段匹配“Alice”或者“Bob”的文檔：

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

過濾查詢

go 查詢

package main

import (
    "context"
    "fmt"
    "log"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/bson"
)

type Student struct {
    Name string
    Score int 
}

func main() {
    // 設置客戶端連接配置
    clientOptions := options.Client().ApplyURI("mongodb://admin:123456@localhost:27017")

    // 連接到MongoDB
    client, err := mongo.Connect(context.TODO(), clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    // 檢查連接
    err = client.Ping(context.TODO(), nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!")


    collection := client.Database("demo").Collection("student")
    

    s1 := Student{"小紅", 66}
    s2 := Student{"小蘭", 70}
    s3 := Student{"小黃", 86}
    s4 := Student{"小張", 92}


    students := []interface{}{s1, s2, s3, s4}
    res, err := collection.InsertMany(context.TODO(), students)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("插入數據完成", res.InsertedIDs)

    
    aggreData := []map[string]interface{}{}

    scoreArray := [5]int{60, 70, 80, 90, 100}

  
    for i := 0; i<len(scoreArray)-1; i++{
        filter := bson.M{
            "score": bson.M{
                "$gt": scoreArray[i],
                "$lt": scoreArray[i+1],
            },
        }
        count, err := collection.CountDocuments(context.TODO(), filter)
        if err != nil {
            log.Printf("get metric error %s", err)
        }
        if count > 0 {
            temp := map[string]interface{}{}
            temp["count"] = count
            aggreData = append(aggreData, temp)
        }
    }
    
    fmt.Println("get finish!")
    for _, value := range aggreData {
        fmt.Println(value)
    }
}

admin> use demo
switched to db demo
demo> show tables
student
demo> db.student.find()
[
  { _id: ObjectId("63e25fa9c6fe361e9f5e7e6e"), name: '小紅', score: 66 },
  { _id: ObjectId("63e25fa9c6fe361e9f5e7e6f"), name: '小蘭', score: 70 },
  { _id: ObjectId("63e25fa9c6fe361e9f5e7e70"), name: '小黃', score: 86 },
  { _id: ObjectId("63e25fa9c6fe361e9f5e7e71"), name: '小張', score: 92 }
]

➜  mongo go run hello.go
Connected to MongoDB!
插入數據完成 [ObjectID("63e26329b1f99ae321f895c2") ObjectID("63e26329b1f99ae321f895c3") ObjectID("63e26329b1f99ae321f895c4") ObjectID("63e26329b1f99ae321f895c5")]
get finish!
map[count:1]
map[count:1]
map[count:1]

bucket命令

以上的命令其實是用來替換bucket命令。bucket命令是3.4的新功能，功能是可以對傳入的一組查詢數據分組查詢並統計。如傳入查詢數據爲[0, 10, 20, 30]，可以查詢出0~10的數據，10~20的數據。

cond := make([]bson.M, 0)
cond = append(cond, bson.M{"$match": bson.M{"user_id": userID}})
cond = append(cond, bson.M{
	"$bucket": bson.D{
		bson.E{Key: "groupBy", Value: "$" + queryField},
		bson.E{Key: "default", Value: "_others_"},
		bson.E{Key: "boundaries", Value: boundries},
		bson.E{Key: "output", Value: bson.D{bson.E{Key: "count", Value: bson.M{"$sum": 1}}}},
	}})
aggreData := s.aggregateMongoQuery(collection, cond)

聚合查詢

mongo命令使用

使用mongodb肯定離不開聚合查詢這種威力強大的操作。下面實現一個提取數組中元素，重命名，匹配區間，統計總數這樣一個操作，使用到的命令包括：

1. unwind：將數組中的每一個值拆分爲單獨的文檔
2. project：提取文檔中元素或重命名
3. match：匹配文檔中元素
4. group：統計文檔

插入數據

demo> db.student.insert({"field": "score", "num": [12, 23, 34, 45, 56, 67, 78, 89]})
{
  acknowledged: true,
  insertedIds: { '0': ObjectId("63e3b26b029e307c2c8c46e6") }
}

mongo命令查詢

demo> db.student.aggregate([{ $unwind:"$num"}, {$project:{value: "$num"}}, {$match: {value:{$gte: 40, $lt: 90}}}, {$group: {_id: "in_40_90", count: {$sum: 1}}}])
[ { _id: 'in_40_90', count: 5 } ]

程序就是將以上命令翻譯成go語言執行

go 聚合查詢

package main

import (
    "context"
    "fmt"
    "log"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/bson"
)

type Student struct {
    Name string
    Score int 
}

func main() {
    // 設置客戶端連接配置
    clientOptions := options.Client().ApplyURI("mongodb://admin:123456@localhost:27017")

    // 連接到MongoDB
    client, err := mongo.Connect(context.TODO(), clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    // 檢查連接
    err = client.Ping(context.TODO(), nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!")

    collection := client.Database("demo").Collection("student")
    
    
    unwind := bson.D{{"$unwind", "$num"}}

    project := bson.D{{
        "$project", bson.D{{
            "value", "$num",
        }},
    }}

    match := bson.D{{
        "$match", bson.D{{
            "value", bson.D{{"$gte", 40}, {"$lt", 90}},
        }},
    }}

    group := bson.D{{
        "$group", bson.D{
            {"_id", nil},
            {"count", bson.D{{"$sum", 1}}},
        },
    }}
    showInfoCursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{unwind, project, match, group})

    var showsWithInfo []map[string]interface{}
    if err = showInfoCursor.All(context.TODO(), &showsWithInfo); err != nil {
        log.Printf("collection %s", err)
        panic(err)
    }

    for _, value := range showsWithInfo {
        fmt.Println(value)
    }

}

➜  mongo go run hello.go
Connected to MongoDB!
map[_id:<nil> count:5]

可以看到結果和mongo命令是一樣的