Go 与 MongoDB 数据库

已于 2023-01-31 21:38:52 修改
阅读量572 收藏 3
点赞数
分类专栏： 数据库编程开发系列 文章标签： 数据库 mongodb golang
于 2023-01-31 21:32:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46457076/article/details/128823499
版权

文章目录

MongoDB 基础入门

MongoDB 简介

基于分布式文件存储的非关系型数据库（NoSQL），为 Web 应用提供可扩展的高性能数据存储解决方案。

数据库操作

  • 启动数据库
mongod
  • 数据库连接
mongodb://[username:password@]host1[:port1][, host2[:port2], ...[/[database][?options]]

mongodb://localhost
mongodb://localhost, localhost:27018, localhost:27019
  • 创建数据库
use DATABASE_NAME

use mongo_db
  • 删除数据库
db.dropDatabase()

集合操作

  • 创建集合
db.createCollection(name, options)

db.createCollection("my_collection")
  • 删除集合
db.collection.drop()

db.my_collection.drop()

文档操作

  • 插入文档
db.collection.insert(document)

db.collection.save(document)

db.my_collection.insert({"name": "tt", "address": "hz"})
  • 查询文档
db.collection.find(query, projection)

db.my_collection.find({})
db.my_collection.find({"name": "tt", "address": "hz"})
db.my_collection.find({"name": {"$ne": "hz"}})
db.my_collection.find({}).count()
db.my_collection.find({}).limit(1)
db.my_collection.find({}).sort({"name": 1})
  • 修改文档
db.collection.update(<query>, <update>, {upsert: <boolean>, multi: <boolean>, writeConcern: <document>})

db.my_collection.update({'name': 'barry'}, {$set: {'address': 'hz'}})

db.collection.save(<document>, {writeConcern: <document>})

db.my_collection.save({"_id": ObjectId("deetete"), "name": "jack", "address": "hz"})
  • 删除文档
db.collection.remove(<query>, {justOne: <boolean>, writeConcern: <document>})

do.my_collection.remove({'name': 'jack'})
  • 去重文档
db.collection.distinct(field, query, options)

db.my_collection.distinct("name", {"address": {"$ne": "sh"}})

Go 访问 MongoDB

连接数据库

package main

import (
		"context"
		"fmt"
		"go.mongodb.org/mongo-driver/mongo"
		"go.mongodb.org/mongo-driver/mongo/options"
		"time"
)
func main() {
		var (
				client     *mongo.Client
				err        error
				db         *mongo.Database
				collection *mongo.Collection
		)
		//连接MongoDB
		if client, err = mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:27017").SetConnectTimeout(5*time.Second)); err != nil {
				fmt.Print(err)
				return
		}
	
		//检查连接
		err = client.Ping(context.TODO(), nil)
		if err != nil {
				fmt.Print(err)
				return
		}
	
		//选择数据库 my_db
		db = client.Database("my_db")

		//选择表 my_collection
		collection = db.Collection("my_collection")
		fmt.Println(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"
		"time"
)

type ExecTime struct {
		StartTime int64 `bson:"startTime"` //开始时间
		EndTime   int64 `bson:"endTime"`   //结束时间
}

type LogRecord struct {
		JobName string `bson:"jobName"` //任务名
		Command string `bson:"command"` //shell命令
		Err     string `bson:"err"`     //脚本错误
		Content string `bson:"content"` //脚本输出
		Tp      ExecTime                //执行时间
}

func main() {
		var (
				client     *mongo.Client
				err        error
				collection *mongo.Collection
				iResult    *mongo.InsertOneResult
				id         primitive.ObjectID
		)
	
	
		if client, err = mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:27017").SetConnectTimeout(5*time.Second)); err != nil {
				fmt.Print(err)
				return
		}
	
		//选择数据库my_db里的某个表
		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.Print(err)
				return
		}
	
		//_id:默认生成一个全局唯一ID
		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"
)

type ExecTime struct {
		StartTime int64 `bson:"startTime"` //开始时间
		EndTime   int64 `bson:"endTime"`   //结束时间
}

type LogRecord struct {
		JobName string `bson:"jobName"` //任务名
		Command string `bson:"command"` //shell命令
		Err     string `bson:"err"`     //脚本错误
		Content string `bson:"content"` //脚本输出
		Tp      ExecTime                //执行时间
}

func main() {
		var (
			client     *mongo.Client
			err        error
			collection *mongo.Collection
			result    *mongo.InsertManyResult
			id         primitive.ObjectID
		)
	
	
		if client, err = mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:27017").SetConnectTimeout(5*time.Second)); err != nil {
				fmt.Print(err)
				return
		}
	
		//选择数据库my_db里的某个表
		collection = client.Database("my_db").Collection("test")

		//批量插入
		result, err = collection.InsertMany(context.TODO(), []interface{}{
			LogRecord{
					JobName: "job multil1",
					Command: "echo multil1",
					Err:     "",
					Content: "1",
					Tp: ExecTime{
							StartTime: time.Now().Unix(),
							EndTime:   time.Now().Unix() + 10,
					},
			},
			LogRecord{
					JobName: "job multil2",
					Command: "echo multil2",
					Err:     "",
					Content: "2",
					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"
		"time"
)

type ExecTime struct {
		StartTime int64 `bson:"startTime"` //开始时间
		EndTime   int64 `bson:"endTime"`   //结束时间
}

type LogRecord struct {
		JobName string `bson:"jobName"` //任务名
		Command string `bson:"command"` //shell命令
		Err     string `bson:"err"`     //脚本错误
		Content string `bson:"content"` //脚本输出
		Tp      ExecTime                //执行时间
}

//查询实体
type FindByJobName struct {
		JobName string `bson:"jobName"` //任务名
}

func main() {
		var (
			client     *mongo.Client
			err        error
			collection *mongo.Collection
			cursor     *mongo.Cursor
	)
	
	
		if client, err = mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:27017").SetConnectTimeout(5*time.Second)); err != nil {
			fmt.Print(err)
			return
		}
	
		//选择数据库my_db里的某个表
		collection = client.Database("my_db").Collection("test")
	cond := FindByJobName{JobName: "job multil1"}
		if cursor, err = collection.Find(
				context.TODO(),
				cond,
				options.Find().SetSkip(0),
				options.Find().SetLimit(2)); 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
				//反序列化Bson到对象
				if cursor.Decode(&lr) != nil {
						fmt.Print(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)
		}
}

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"
		"time"
)

type ExecTime struct {
		StartTime int64 `bson:"startTime"` //开始时间
		EndTime   int64 `bson:"endTime"`   //结束时间
}

type LogRecord struct {
		JobName string `bson:"jobName"` //任务名
		Command string `bson:"command"` //shell命令
		Err     string `bson:"err"`     //脚本错误
		Content string `bson:"content"` //脚本输出
		Tp      ExecTime                //执行时间
}

//查询实体
type FindByJobName struct {
		JobName string `bson:"jobName"` //任务名
}

func main() {
		var (
			client     *mongo.Client
			err        error
			collection *mongo.Collection
			cursor     *mongo.Cursor
		)
	
	
		if client, err = mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:27017").SetConnectTimeout(5*time.Second)); err != nil {
				fmt.Print(err)
				return
		}
	
		//选择数据库my_db里的某个表
		collection = client.Database("my_db").Collection("test")
		filter := bson.M{"jobName":"job multil1"}
		if cursor, err = collection.Find(
				context.TODO(),
				filter,
				options.Find().SetSkip(0),
				options.Find().SetLimit(2)); err != nil {
				log.Fatal(err)
		}
		defer func() {
				if err = cursor.Close(context.TODO()); err != nil {
						log.Fatal(err)
				}
		}()
	
		var results []LogRecord
		if err = cursor.All(context.TODO(), &results); err != nil {
				log.Fatal(err)
		}
	
		for _, result := range results {
				fmt.Println(result)
		}
}

BSON 复合查询

BSON，JSON 的二进制表示，两大类型表示 BSON 数据：

一、D类型

4 个子类:

  • D：BSON 文档，有序 map 。
  • M：无序 map 。
  • A：一个 BOSN 数组。
  • E：D 中的一个元素。
bson.D{{
		"name",
		bson.D{{
				"$in",
				bson.A{"Jim", "Jack"},
		}}
}}

二、Raw 类型

验证字节切片，反序列化 BSON 。

package main

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

func main() {
		testM := bson.M{
			"jobName": "job multi1",
		}
		var raw bson.Raw
		tmp, _ := bson.Marshal(testM)
		bson.Unmarshal(tmp, &raw)

		fmt.Println(testM)
		fmt.Println(raw)
}

聚合查询

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"
		"time"
)

func main() {
		var (
				client     *mongo.Client
				collection *mongo.Collection
				err        error
				cursor     *mongo.Cursor
		)
	
		if client, err = mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:27017").SetConnectTimeout(5*time.Second)); err != nil {
				fmt.Print(err)
				return
		}
	
		collection = client.Database("my_db").Collection("test")
		//按照jobName分组,countJob中存储每组的数目
		groupStage := mongo.Pipeline{bson.D{
				{"$group", bson.D{
						{"_id", "$jobName"},
						{"countJob", bson.D{
						{"$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
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
GO 操作MongoDB
qq_52209929的博客
10-18 2231
GO 操作MongoDB
MongoDB 数据库
qt的博客
03-13 812
1. NoSQL 简介 简介 关系型数据库遇到的问题 2008 年左右，网站 、 论坛、社交网络开始高速发展，关系型数据库的地位受到了很大的挑战 。关系型数据库的以下问题逐渐凸显： • 难以应付每秒上万次的高并发数据写入 。 • 查询上亿量级数据的速度极其缓慢 。 • 分库、分表形成的子库到达一定规模后难以进一步扩展 。 • 分库、分表 的规则可能会因为需求变更而发生变更。 • 修改表结构困难 。 在很多 互联网应用场景下 ， 对数据联表的查询需求不是那么强烈 ，也并不需要在数据写入后立刻读取，但对数据的读
Go学习——使用MongoDB
脑袋装水的博客
04-03 6062
目录MongoDB添加mongodb依赖连接MongoDB:操作数据库CRUD操作插入文档插入单个文档插入多条文档更新文档更新单个文档更新多个文档查找文档查询单个文档：查询多个文档：删除文档 MongoDB MongoDB是一个高性能，开源，无模式的文档型数据库，是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，采用的是类似json的bjson格式来存储数据，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，
2024年最全Golang与MongoDB的完美组合_golang mongodb(1)，Golang程序员必会
最新发布
2401_84924864的博客
05-11 392
本文介绍了Golang与MongoDB的完美组合。我们首先了解了Golang和MongoDB的特点和优势，然后演示了如何使用Golang操作MongoDB数据库。通过连接数据库、插入数据和查询数据的示例，我们展示了Golang与MongoDB的强大功能和简洁易用的特点。希望本文能对你了解和使用Golang操作MongoDB提供一些帮助！既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！
Go语言操作mongodb
m0_56137272的博客
09-01 2314
以上就是今天要讲的内容，如何使用go语言操作mongodb，展示了mongodb的部分指令，而mongodb提供的指令远不止这些，在学习的过程中做笔记，以防日后需要使用mongodb会忘记怎么使用，毕竟好记性不如烂笔头。
一文教你Go语言如何轻松使用MongoDB
weixin_59801183的博客
05-09 1595
本文档详细介绍了如何使用Go语言对MongoDB进行基础操作。我们将学习如何使用Go连接MongoDB、插入文档、查询文档、更新文档和删除文档。
Golang与MongoDB的完美组合
hitpter的专栏
11-28 1229
Golang是一种开源的静态强类型编程语言，由Google开发。它具有简洁的语法、高效的编译器和并发性能，使得它成为处理大型数据和高并发场景的理想选择。Golang具有丰富的标准库和强大的第三方库生态系统，使开发人员能够快速构建高性能的应用程序。本文介绍了Golang与MongoDB的完美组合。我们首先了解了Golang和MongoDB的特点和优势，然后演示了如何使用Golang操作MongoDB数据库。
MongoDB和MongoDB云数据库浅谈
cug_jiang126com的专栏
07-28 3653
MongoDB的特点和适用场景 实用性 MongoDB是一个面向文档的数据库，它并不是关系型数据库，直接存取BSON，这意味着MongoDB更加灵活，因为可以在文档中直接插入数组之类的复杂数据类型，并且文档的key和value不是固定的数据类型和大小，所以开发者在使用MongoDB时无须预定义关系型数据库中的”表”等数据库对象，设计数据库将变得非常方便，可以大大地提升开发进度。下面这个表格是M
Golang对MongoDB数据库的操作简单封装教程
01-03
mgo（音mango）是MongoDB的Go语言驱动，它用基于Go语法的简单API实现了丰富的特性，并经过良好测试。 初始化 操作没有用户权限的MongoDB var globalS *mgo.Session func init() { s, err := mgo.Dial(dialInfo) ...
老生常谈MongoDB数据库基础操作
12-16
此外，MongoDB兼容多种编程语言，包括Java、Python、Node.js等，这意味着开发人员可以根据自己的技术栈轻松集成MongoDB。 总的来说，MongoDB是一个适合于高并发、数据模型不固定且需要高效查询的场景的数据库。它的...
mongodb数据库的6个安全设置命令
12-15
MongoDB 是一个流行的开源文档型数据库，以灵活性和高性能著称。为了确保数据的安全性，MongoDB 提供了多种安全设置命令。以下是标题和描述中提到的六个关键安全设置步骤的详细说明： 1. **安全认证模式启动**： ...
Node.js操作mongodb数据库
12-14
接下来，你需要连接到MongoDB数据库。在你的主应用程序文件（如`app.js`）中，引入mongoose模块并调用`mongoose.connect()`函数，传入MongoDB的URL字符串。例如： ```javascript var mongoose = require('mongoose')...
mongoDB数据库的基本操作
12-14
键盘上面的 window+R键 进入到mongo数据库的环境 此时的这个服务千万别关，最小化就可以了 然后再次window+R 键再开一个dos界面 输入mongo 就可以了 查看数据库相关的信息 show dbs:查看当前的数据库 首先进入...
Golang（go）+mongodb开发个人遇到坑及用法总结汇总
justtest02的博客
08-30 982
Golang（go）+ mongodb开发个人遇到坑及用法总结汇总 用享
golang分布式中间件之mongodb
SMILY12138的博客
04-15 873
综上所述，golang分布式中间件之mongodb是一种强大的分布式系统解决方案，它可以为企业提供高可用性、高扩展性和灵活性的数据存储和查询服务。随着互联网的快速发展，分布式系统的需求也越来越强烈，因此如何通过分布式中间件实现MongoDB的分布式部署和高可用性成为了一个重要问题。分片集群是MongoDB中的一种扩展性解决方案，它将数据分片存储在不同的节点上，从而实现横向扩展。分布式中间件是指在分布式系统中运行的软件组件，它们提供了通信、协调和管理等功能，从而为分布式应用程序提供支持。
使用Golang连接MongoDB方法详解
路多辛的所思所想
04-17 1068
Golang连接MongoDB的库有很多，本文主要讲解使用MongoDB官方驱动 go.mongodb.org/mongo-driver/mongo 连接MongoDB的方法。接下来以标准连接字符串格式来做讲解。
Go 使用 MongoDB
rubys007的博客
01-25 1028
在 MongoDB 中存储的 JSON 文档叫 BSON，是以二进制形式存储的。Go 的 MongoDB 驱动有两个表示 BSON 数据的类型：D 类型和 Raw 类型。如果想要查询一个文档，同样需要提供一个 filter 文档来筛选，同时需要一个接收结果的指针。为了查询单个文档，可以使用。下面的例子中，我们在 Find 的时候同时指定了额外的一些选项，这里我们设置最多获取的记录数为 2。一旦你连接到了数据库，我们就可以开始添加或者操作数据库中的数据了。类型的参数来筛选数据库中特定的文档，然后更新它。
go mongo常见几种查询
len_yue_mo_fu的博客
03-02 2643
go mongo常见几种查询演示结构体建立连接and查询查询id=1 and name="test"或查询查询 name="test" 或者 "test2"in查询查询 name in("test1","test2","test3")模糊查询查询name中包含 test字符串的数据 演示结构体 type Score struct { Subject string `bson:"subject" json:"subject"` Score int `bson:"score" json:"score"`
mog使用指南
weixin_30396699的博客
10-17 537
mog使用指南 mgo简介 mgo（音mango）是MongoDB的Go语言驱动，它用基于Go语法的简单API实现了丰富的特性，并经过良好测试。 官方网站：http://labix.org/mgo。 golang.tc（golangtc.com）网站的数据存储就是是用的MongoDB+mgo。近一年使用下来表现良好。 API文档 下面是mgo、mgo/bson、mgo/txn的在线文档。...
golang 连接Mongodb数据库
08-16
使用Golang连接MongoDB数据库可以使用第三方库 like "go.mongodb.org/mongo-driver/mongo"。以下是一个简单的示例代码，展示了如何连接到MongoDB数据库，并执行一些基本的操作： ```go package main import ( ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

물の韜

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

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

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

打赏作者

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

抵扣说明：

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

余额充值