Go 语言操作 MongoDb

已于 2023-10-26 16:39:14 修改
阅读量500 收藏
点赞数
分类专栏： Go后端 文章标签： golang mongodb 开发语言
于 2023-10-26 15:21:42 首次发布
桂林电子科技大学 计算机与信息安全学院 蒋熹煜
本文链接：https://blog.csdn.net/qq_61735602/article/details/134054799
版权

文章目录

连接数据库

package main

import (
	"context"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
)

var mgoCli *mongo.Client

func initDb() {
	var err error
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	mgoCli, err = mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	err = mgoCli.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}
}
func MgoCli() *mongo.Client {
	if mgoCli == nil {
		initDb()
	}
	return mgoCli
}

func main() {
	//连接数据库
	var (
		client     = MgoCli()
		db         *mongo.Database
		collection *mongo.Collection
	)
	db = client.Database("my_db")
	collection = db.Collection("my_collection")
	collection = collection
}

插入数据库

插入一条数据

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"time"
)

var mgoCli *mongo.Client

func initDb() {
	var err error
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	mgoCli, err = mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	err = mgoCli.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}
}

func MgoCli() *mongo.Client {
	if mgoCli == nil {
		initDb()
	}
	return mgoCli
}

// 插入一条数据
type ExecTime struct {
	StartTime int64 `bson:"startTime"`
	EndTime   int64 `bson:"endTime"`
}

type LogRecord struct {
	JobName string `bson:"jobName"`
	Command string `bson:"command"`
	Err     string `bson:"err"`
	Content string `bson:"content"`
	Tp      ExecTime
}

func main() {
	var (
		client     = MgoCli()
		err        error
		collection *mongo.Collection
		iResult    *mongo.InsertOneResult
		id         primitive.ObjectID
	)
	collection = client.Database("my_db").Collection("my_collection")

	logRecord := LogRecord{
		JobName: "job1",
		Command: "echo 1",
		Err:     "",
		Content: "1",
		Tp: ExecTime{
			StartTime: time.Now().Unix(),
			EndTime:   time.Now().Unix() + 10,
		},
	}
	if iResult, err = collection.InsertOne(context.TODO(), logRecord); err != nil {
		fmt.Println(err)
		return
	}
	id = iResult.InsertedID.(primitive.ObjectID)
	fmt.Println("自增 ID", id.Hex())
}

批量插入数据

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"time"
)

var mgoCli *mongo.Client

func initDb() {
	var err error
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	mgoCli, err = mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	err = mgoCli.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}
}

func MgoCli() *mongo.Client {
	if mgoCli == nil {
		initDb()
	}
	return mgoCli
}

// 插入一条数据
type ExecTime struct {
	StartTime int64 `bson:"startTime"`
	EndTime   int64 `bson:"endTime"`
}

type LogRecord struct {
	JobName string `bson:"jobName"`
	Command string `bson:"command"`
	Err     string `bson:"err"`
	Content string `bson:"content"`
	Tp      ExecTime
}

func main() {
	var (
		client     = MgoCli()
		err        error
		collection *mongo.Collection
		result     *mongo.InsertManyResult
		id         primitive.ObjectID
	)
	collection = client.Database("my_db").Collection("test")

	result, err = collection.InsertMany(context.TODO(), []interface{}{
		LogRecord{
			JobName: "job1",
			Command: "echo 1",
			Err:     "",
			Content: "1",
			Tp: ExecTime{
				StartTime: time.Now().Unix(),
				EndTime:   time.Now().Unix() + 10,
			},
		},
		LogRecord{
			JobName: "job1",
			Command: "echo 1",
			Err:     "",
			Content: "1",
			Tp: ExecTime{
				StartTime: time.Now().Unix(),
				EndTime:   time.Now().Unix() + 10,
			},
		},
	})
	if err != nil {
		log.Fatal(err)
	}
	if result == nil {
		log.Fatal("result nil")
	}
	for _, v := range result.InsertedIDs {
		id = v.(primitive.ObjectID)
		fmt.Println("自增 ID", id.Hex())

	}
}

查询数据

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
)

var mgoCli *mongo.Client

func initDb() {
	var err error
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	mgoCli, err = mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	err = mgoCli.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}
}

func MgoCli() *mongo.Client {
	if mgoCli == nil {
		initDb()
	}
	return mgoCli
}

// 插入一条数据
type ExecTime struct {
	StartTime int64 `bson:"startTime"`
	EndTime   int64 `bson:"endTime"`
}

type LogRecord struct {
	JobName string `bson:"jobName"`
	Command string `bson:"command"`
	Err     string `bson:"err"`
	Content string `bson:"content"`
	Tp      ExecTime
}

type FindByJobName struct {
	JobName string `bson:"jobName"`
}

func main() {
	var (
		client     = MgoCli()
		err        error
		collection *mongo.Collection
		cursor     *mongo.Cursor
	)
	collection = client.Database("my_db").Collection("table1")
	cond := FindByJobName{JobName: "job multil"}
	findOptions := options.Find().SetSkip(0).SetLimit(2)
	if cursor, err = collection.Find(context.TODO(), cond, findOptions); err != nil {
		fmt.Println(err)
		return
	}
	defer func() {
		if err = cursor.Close(context.TODO()); err != nil {
			log.Fatal(err)
		}
	}()
	for cursor.Next(context.TODO()) {
		var lr LogRecord
		if cursor.Decode(&lr) != nil {
			fmt.Println(err)
			return
		}
		fmt.Println(lr)
	}
	var results []LogRecord
	if err = cursor.All(context.TODO(), &results); err != nil {
		log.Fatal(err)
	}
	for _, result := range results {
		fmt.Println(result)
	}
}

用 BSON 进行复合查询

聚合查询

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
)

var mgoCli *mongo.Client

func initDb() {
	var err error
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	mgoCli, err = mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	err = mgoCli.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}
}

func MgoCli() *mongo.Client {
	if mgoCli == nil {
		initDb()
	}
	return mgoCli
}

func main() {
	client := MgoCli()
	collection := client.Database("my_db").Collection("table1")
	groupStage := mongo.Pipeline{
		bson.D{
			{"$group", bson.D{
				{"_id", "$jobName"},
				{"countJob", bson.D{
					{"$sum", 1},
				}},
			}},
		},
	}

	cursor, err := collection.Aggregate(context.TODO(), groupStage)
	if err != nil {
		log.Fatal(err)
	}
	defer func() {
		err = cursor.Close(context.TODO()) // 修正关闭游标的错误处理
		if err != nil {
			log.Fatal(err)
		}
	}()

	var results []bson.M
	err = cursor.All(context.TODO(), &results)
	if err != nil {
		log.Fatal(err)
	}

	for _, result := range results {
		fmt.Println(result)
	}
}

更新数据

package main

import (
	"context"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
)

var mgoCli *mongo.Client

func initDb() {
	var err error
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	mgoCli, err = mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	err = mgoCli.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}
}

func MgoCli() *mongo.Client {
	if mgoCli == nil {
		initDb()
	}
	return mgoCli
}

type UpdateByJobName struct {
	Command string `bson:"command"`
	Content string `bson:"content"`
}

func main() {
	var (
		client     = MgoCli()
		collection *mongo.Collection
		err        error
		uResult    *mongo.UpdateResult
	)
	collection = client.Database("my_db").Collection("table1")
	filter := bson.M{"jobName": "job multil"}
	// bson.M{"$inc",bson.M{"age",-1,}}
	//bson.M{"$push",bson.M{"interests","Golang",}}
	//bson.M{"$pull",bson.M{"interests","Golang",}}
	update := bson.M{"$set": UpdateByJobName{
		Command: "byModel",
		Content: "model",
	}}
	if uResult, err = collection.UpdateMany(context.TODO(), filter, update); err != nil {
		log.Fatal(err)
	}
	log.Println(uResult.MatchedCount)
}

删除数据


package main

import (
	"context"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"time"
)

var mgoCli *mongo.Client

func initDb() {
	var err error
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	mgoCli, err = mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	err = mgoCli.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}
}

func MgoCli() *mongo.Client {
	if mgoCli == nil {
		initDb()
	}
	return mgoCli
}

type DeleteCond struct {
	BeforeCond TimeBeforeCond `bson:"tp.startTime"`
}

// startTime小于某时间，使用这种方式可以对想要进行的操作($set、$group等)提前定义
type TimeBeforeCond struct {
	BeforeTime int64 `bson:"$lt"`
}

func main() {
	var (
		client     = MgoCli()
		collection *mongo.Collection
		err        error
		uResult    *mongo.DeleteResult
		delCond    *DeleteCond
	)
	collection = client.Database("my_db").Collection("table1")

	//删除jobName为job0的数据
	delCond = &DeleteCond{
		BeforeCond: TimeBeforeCond{
			BeforeTime: time.Now().Unix()}}
	if uResult, err = collection.DeleteMany(context.TODO(),
		delCond); err != nil {
		log.Fatal(err)
	}
	log.Println(uResult.DeletedCount)
}


package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
)

var mgoCli *mongo.Client

func initDb() {
	var err error
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	mgoCli, err = mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	err = mgoCli.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}
}

func MgoCli() *mongo.Client {
	if mgoCli == nil {
		initDb()
	}
	return mgoCli
}

// 分组
type Group struct {
	Group interface{} `bson:"$group"`
}

// 求和
type Sum struct {
	Sum interface{} `bson:"$sum"`
}

func main() {
	var (
		client     = MgoCli()
		collection *mongo.Collection
		err        error
		cursor     *mongo.Cursor
	)
	collection = client.Database("my_db").Collection("table1")

	groupStage := []Group{}
	groupStage = append(groupStage, Group{
		Group: bson.D{
			{"_id", "$jobName"},
			{"countJob", Sum{Sum: 1}},
		},
	})

	if cursor, err = collection.Aggregate(context.TODO(),
		groupStage); err != nil {
		log.Fatal(err)
	}
	defer func() {
		if err = cursor.Close(context.TODO()); err != nil {
			log.Fatal(err)
		}
	}()
	var results []bson.M
	if err = cursor.All(context.TODO(), &results); err != nil {
		log.Fatal(err)
	}
	for _, result := range results {
		fmt.Println(result)
	}
}
小蒋的学习笔记
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Go开源宝藏】Go语言操作 MongoDB
面向生活编程
02-01 3316
文章目录1. MongoDB简介2. Go连接MongoDB3. insert 插入3.1 插入单条数据3.2 插入多条数据4. find 查询4.1 单条查询4.2 多条查询4.3 复合查询4.3.1 $regex 模糊查询4.3.2 in($in)4.3.3 各种比较函数4.3.4 复合查询4.3.5 聚类`$sum`例子：`$avg` 例子`$min例子`5. update 更新5.1 更新单条5.2 更新多条6. delete 删除6.1 删除单条6.2 删除多条 1. MongoDB简介 Mong
Go 操作 mongoDB
weixin_41335923的博客
05-06 1375
Go 语言操作 mongoDB，并记录遇到的错误与解决方案
Go语言操作mongodb
m0_56137272的博客
09-01 2425
以上就是今天要讲的内容，如何使用go语言操作mongodb，展示了mongodb的部分指令，而mongodb提供的指令远不止这些，在学习的过程中做笔记，以防日后需要使用mongodb会忘记怎么使用，毕竟好记性不如烂笔头。
go 语言操作MongoDB数据库
qq_42170897的博客
10-18 966
go 连接MongoDB，并CURD
GO 操作MongoDB
qq_52209929的博客
10-18 2260
GO 操作MongoDB
Go语言学习笔记—golang操作MongoDB数据库
qq_39280718的博客
08-06 2251
golang操作MongoDB数据库
golang操作mongodb的方法
09-10
综上所述，Go语言操作MongoDB的基本步骤包括引入`mgo`库，定义数据结构，建立数据库连接，操作集合（插入、查询和显示数据）。在实际项目中，你可能需要处理更多复杂场景，如错误处理、分页查询、更新和删除操作等。...
第一个go程序
zhourongxiang1的博客
08-28 91
hello.go所在目录。
Java共享内容通信 VS Golang通信共享内存
Czh的博客
08-24 767
最近在学习并发编程的时候，发现一个很有意思的点：Java基于共享共享内存通信，而Golang则是通过通信共享内存。为什么？下面我们一起一探究竟！
go: cannot find main module, but found .git/config in /GoByExample
最新发布
weixin_63566388的博客
08-28 115
运行命令来初始化一个新的 Go 模块：go mod init your-module-name。模块（也就是 Go 模块管理器所管理的模块），并且在当前目录下发现了一个。这个错误消息表明在尝试编译或运行 Go 代码时，Go 编译器无法找到。要解决这个问题，你需要初始化一个 Go 模块。
Golang学习笔记-Golang中的锁
qq_24428851的博客
08-25 1235
Go标准库的中的sync.Cond是一个条件变量，它可以让一系列的goroutine都在满足特定条件下时候被唤醒，每一个 sync.Cond 结构体在初始化时都需要传入一个互斥锁，我们可以通过下面的例子了解它的使用方法。因为请求的哈希在业务上一般表示相同的请求，所以上述代码使用它作为请求的键。这个是Go语言的扩展包中提供的另外一个信号量，它能够在一个服务中抑制对下游的多次重复请求，比如在redis的缓存雪崩中，能够限制对同一个 Key 的多次重复请求，减少对下游的瞬时流量。上述两个加起来，只占用8个字节。
Go 中间件学习
程序媛平平无奇的一天
08-28 426
/ 在处理请求之前执行的操作// 继续处理请求c.Next()// 在处理请求之后执行的操作在这个例子中，中间件函数返回一个，它包含了在请求处理前后执行的代码。通过自定义中间件，你可以在 Gin 应用中轻松实现如日志记录、身份验证等通用功能。自定义中间件可以应用于整个路由组或单个路由，且中间件可以在请求处理的不同阶段执行逻辑，使你的应用程序更加灵活和易于维护。
Go 服务调试精解
禅与代码的艺术
08-28 474
首先讲解了 Go 语言为我们提供的性能分析利器 pprof,并分别介绍了在分析内存指标、CPU指标、锁与阻塞指标等方面的应用。然后讲解了另外一款性能分析工具 Trace,它可以跟踪并采集 Go 进程的诸多事件，通过这些事件可以很清楚地知道 Go 进程每时每刻都在做什么，这对分析并解决 Go 服务性能问题是非常有用的。最后，介绍了 Go 语言专用的调试工具 dlv,并通过具体的例子讲解了如何使用 dlv 调试 Go 程序。
golang学习笔记——grom连接mysql
e891377的专栏
08-25 1132
Golang的ORM库旨在对开发人员友好。
Golang | Leetcode Golang题解之第372题超级次方
weixin_66442839的博客
08-25 346
Golang | Leetcode Golang题解之第372题超级次方
Go 语言生产服务故障案例精析
禅与代码的艺术
08-28 878
首先列举了两种导致 502 状态码的情况，包括 panic 异常和长连接。其次，介绍了服务假死问题的排查以及 HTTP 客户端引发的问题。
在Linux下搭建go环境
Au_ust的博客
08-21 518
保存后执行source ~/.bashrc，更新一下。如果能够显示正确的版本号则证明配置成功。
go.uber.org/ratelimit 源码分析
小熙的博客
08-28 442
go 提供了一用来接口限流的包。其中包正是基于漏桶算法实现的。指的是每秒平均多少次，在运行程序后，并不会严格按照官方给的样例输出。
go语言操作mongodb，怎么用事务回滚进行写入删除等
08-06
在Go语言中操作MongoDB，可以使用事务回滚来进行写入、删除等操作。以下是一些基本操作的示例： 1. 初始化MongoDB客户端和数据库连接： ```go clientOptions := options.Client().ApplyURI("mongodb://localhost:...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小蒋的学习笔记

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值