Go 语言操作 MongoDb

这篇具有很好参考价值的文章主要介绍了Go 语言操作 MongoDb。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

连接数据库

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

文章来源地址https://www.toymoban.com/news/detail-716588.html

到了这里,关于Go 语言操作 MongoDb的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Golang】VsCode下开发Go语言的环境配置(超详细图文详解)

    📓推荐网站(不断完善中):个人博客 📌个人主页:个人主页 👉相关专栏:CSDN专栏、个人专栏 🏝立志赚钱,干活想躺,瞎分享的摸鱼工程师一枚 ​ 话说在前,Go语言的编码方式是 UTF-8 ,理论上你直接使用文本进行编辑也是可以的,当然为了提升我们的开发效率我们还是需

    2024年02月07日
    浏览(83)
  • Go实现mongodb增删改查的工具类

    mongodb官方go介绍 使用例子https://www.mongodb.com/docs/drivers/go/current/fundamentals/connection/#connection-example 快速入门https://www.mongodb.com/docs/drivers/go/current/quick-start/ 要对mongodb进行增删改查,需要添加对应的go驱动依赖,安装命令 2.1 Mongodb工具类代码 封装的工具类mongodao.go 2.2 使用例子 使用

    2024年02月13日
    浏览(36)
  • SpringBoot 集成 Spring Data Mongodb 操作 MongoDB 详解

    MongoDB 是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,且与关系数据库的最为相像的。它支持的数据结构非常松散,是类似 json 的 bson 格式,因此可以存储比较复杂的数据类型。Mongo 最大的特点是它支持的查询语言非常强大,其语法有点

    2024年02月02日
    浏览(45)
  • 前端Vue Node.js + Express + MongoDB 构建的后端服务API接口

    构建一个使用 Vue.js 作为前端, Node.js + Express + MongoDB 作为后端服务的全栈应用涉及到多个步骤。这里简要概述整个过程,并提供一些基本的代码示例来帮助你开始。 安装 MongoDB: 根据你的操作系统从 MongoDB 官网 下载并安装 MongoDB。 启动 MongoDB 服务: 安装完成后,根据 MongoDB 的

    2024年04月14日
    浏览(51)
  • MongoDB实验——在Java应用程序中操作 MongoDB 数据

    1. 启动MongoDB Shell 2. 切换到admin数据库,使用root账户 3.开启Eclipse,创建Java Project项目,命名为MongoJava File -- New -- Java Project 4.在MongoJava项目下新建包,包名为mongo MongoJava右键 -- New -- mongo 5. 在mongo包下新建类,类名为mimalianjie mongo右键 -- New -- Class 6. 添加项目依赖的jar包,右键单

    2024年02月10日
    浏览(35)
  • MongoDB常规操作

    登陆数据库 在终端输入 mongosh 4.1 数据库操作 4.1.1 查看 : MongoDB对于数据库的查看 4.1.2 创建 对于数据库的创建,MongoDB并未提供一个独立的接口,而是使用类似于mysql这种use database 的语法,当使用的数据库不存在时则进行创建 【注】 当只是use new database 时,没有进行集合、文

    2024年01月19日
    浏览(30)
  • MongoDB操作基本教程

    v6.0.7 bin目录下默认可执行文件说明 mongod 实例,这样不仅减少资源竞争,而且服务器故障也不会同时影响到多个服务。 mongos 在分片集群中扮演路由的角色,提供客户端和分片之间的接口。 mongosh 是 MongoDB 集成的交互式 shell 工具。 数据库工具 需要另外下载:https://www.mongodb

    2024年02月16日
    浏览(35)
  • [Mongodb 5.0]聚合操作

     本文对应Aggregation Operations — MongoDB Manual    正文 此章节主要介绍了Aggregation Pipeline,其实就是将若干个聚合操作放在管道中进行执行,每一个聚合操作的结果作为下一个聚合操作的输入,每个聚合指令被称为一个stage。 在正式开始学习聚合操作前,请先按照下面的方式在你

    2024年02月12日
    浏览(48)
  • MongoDB聚合操作

    提示:以下是本篇文章正文内容,MongoDB 系列学习将会持续更新 单一作用聚合 :提供了对常见聚合过程的简单访问,操作都从单个集合聚合文档。 函数 描述 db.collection.estimatedDocumentCount() 忽略查询条件,返回集合或视图中所有文档的计数 db.collection.count() 返回与find()集合或视

    2024年02月03日
    浏览(31)
  • mongodb数据库操作

    1、启动mongodb 在mongodb启动命令中 --dbpath 指定mongodb的数据存储路径 --logpath 指定mongodb的日志存储路径 2、停止mongodb 第一步先进入mongo命令行模式 第二步,使用use admin 命令进入admin数据库 第三步,执行 db.shutdownServer()命令 停止服务。代码及显示如下:  2 、导出Mongodb数据 mon

    2024年02月09日
    浏览(50)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包