MongoDB的Go语言操作示例总结

于 2024-06-21 22:42:54 发布
阅读量996 收藏 19
点赞数 28
分类专栏： Go语言实践笔记 文章标签： mongodb golang 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyz_1987/article/details/139867394
版权

目录

前提条件

连接到MongoDB

简单示例

插入文档

查询文档

查询单个文档

查询多个文档

更新文档

更新单个文档

更新多个文档

删除文档

删除单个文档

删除多个文档

聚合管道

常见聚合操作符

$match

$group

$project

$sort

$limit

$skip

$lookup

$unwind

 示例

Go中的聚合管道使用示例

完整示例

MongoDB是一个流行的NoSQL数据库，而Go语言是一种简洁、高效的编程语言。这两者组合可以给应用程序提供强大的数据存储和操作能力。

在Go语言中操作MongoDB需要使用官方MongoDB Go驱动程序。以下总结下在Go语言中使用MongoDB数据库涉及到的一些基本操作。如插入文档、查询文档，如何在Go中进行连接、增、删、改、查等常用操作，以及如何使用聚合管道进行复杂查询。

前提条件

1.确保您已经安装了MongoDB和Go语言环境。

2.安装MongoDB Go驱动程序，可以使用go get命令来安装：

go get go.mongodb.org/mongo-driver/mongo

新建个项目文件夹，在下面新建main.go文件，执行yourprj换成你的包名。

go mod init yourprj

不用非得执行上面的go get 方式，直接项目代码中import需要的包，执行go mod tidy即可。 

连接到MongoDB

首先，需要连接到MongoDB实例：

package main

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

func main() {
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    defer func() {
        if err = client.Disconnect(ctx); err != nil {
            log.Fatal(err)
        }
    }()

    // 获取数据库和集合
    db := client.Database("testDB")
    collection := db.Collection("users")

    // 接下来的操作在这里进行
}

注意事项

上面的连接url参数针对未开启认证的可以连接成功，若开启有用户名密码验证则需要类似如下的连接参数：

"mongodb://user:yourpwd@localhost:27017/?tls=false&authSource=test1"

简单示例

package main

import (
	"context"
	"fmt"
	"log"
  "time"

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

type User struct {
	Name  string `json:"name"`
	Email string `json:"email"`
  Age   int    `bson:"Agg"`
}
// ... 上面User结构体定义 ...

func main() {
	// 连接MongoDB
	clientOptions := options.Client().ApplyURI("mongodb://test1:111111@localhost:27017/?tls=false&authSource=test1")
	client, err := mongo.Connect(context.Background(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	defer func() {
		if err = client.Disconnect(context.Background()); err != nil {
			log.Fatal(err)
		}
	}()

	// 解析JSON字符串到User结构体（假设已经完成）
	user := User{Name: "Alice", Email: "alice@example.com",Age:22}

	// 选择数据库和集合
	collection := client.Database("test1").Collection("users")

	// 插入文档
	insertResult, err := collection.InsertOne(context.TODO(), user)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Inserted ID:", insertResult.InsertedID)
 
	// 插入文档
	doc := bson.D{{"age", 30},{"name", "Alice2"},  {"createdAt", time.Now()}}
	insertResult, err = collection.InsertOne(context.TODO(), doc)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Inserted ID:", insertResult.InsertedID)

	// 更新文档
	filter := bson.D{{"name", "Alice1"}}
	update := bson.D{{"$set", bson.D{{"age", 31}}}}
	updateResult, err := collection.UpdateOne(context.TODO(), filter, update)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Modified Count:", updateResult.ModifiedCount)

	// 删除文档
  filter = bson.D{{"age", 22}}
	deleteResult, err := collection.DeleteOne(context.TODO(), filter)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Deleted Count:", deleteResult.DeletedCount)

	// 查找单个文档
	var singleResult bson.M
	err = collection.FindOne(context.TODO(), bson.D{}).Decode(&singleResult)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Single Document:", singleResult)

	// 查找所有文档
	cursor, err := collection.Find(context.TODO(), bson.D{})
	if err != nil {
		log.Fatal(err)
	}
	defer cursor.Close(context.TODO())
 
	for cursor.Next(context.TODO()) {
		var result bson.M
		err := cursor.Decode(&result)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println("Document:", result)
	}

	// 过滤查找
	filteredCursor, err := collection.Find(context.TODO(), bson.D{{"age", bson.D{{"$gt", 31}}}})
	if err != nil {
		log.Fatal(err)
	}
	defer filteredCursor.Close(context.TODO())
 
	for filteredCursor.Next(context.TODO()) {
		var filteredDoc bson.M
		err := filteredCursor.Decode(&filteredDoc)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println("Filtered Document:", filteredDoc)
	}
}

插入文档

    user := map[string]interface{}{"name": "Alice", "age": 29}
    _, err = collection.InsertOne(ctx, user)
    if err != nil {
        log.Fatal(err)
    }

    users := []interface{}{
        map[string]interface{}{"name": "Bob", "age": 31},
        map[string]interface{}{"name": "Charlie", "age": 25},
    }
    _, err = collection.InsertMany(ctx, users)
    if err != nil {
        log.Fatal(err)
    }

查询文档

查询单个文档

    var result map[string]interface{}
    filter := map[string]interface{}{"name": "Alice"}
    err = collection.FindOne(ctx, filter).Decode(&result)
    if err != nil {
        log.Fatal(err)
    }
    log.Println(result)

查询多个文档

    filter = map[string]interface{}{"age": map[string]interface{}{"$gte": 30}}
    cursor, err := collection.Find(ctx, filter)
    if err != nil {
        log.Fatal(err)
    }
    defer cursor.Close(ctx)

    var results []map[string]interface{}
    if err = cursor.All(ctx, &results); err != nil {
        log.Fatal(err)
    }
    for _, result := range results {
        log.Println(result)
    }

更新文档

更新单个文档

    filter = map[string]interface{}{"name": "Bob"}
    update := map[string]interface{}{"$set": map[string]interface{}{"age": 32}}
    _, err = collection.UpdateOne(ctx, filter, update)
    if err != nil {
        log.Fatal(err)
    }

更新多个文档

    filter = map[string]interface{}{"age": map[string]interface{}{"$lt": 30}}
    update = map[string]interface{}{"$set": map[string]interface{}{"valid": true}}
    _, err = collection.UpdateMany(ctx, filter, update)
    if err != nil {
        log.Fatal(err)
    }

删除文档

删除单个文档

    filter = map[string]interface{}{"name": "Charlie"}
    _, err = collection.DeleteOne(ctx, filter)
    if err != nil {
        log.Fatal(err)
    }

删除多个文档

    filter = map[string]interface{}{"valid": true}
    _, err = collection.DeleteMany(ctx, filter)
    if err != nil {
        log.Fatal(err)
    }

聚合管道

MongoDB的聚合管道（Aggregation Pipeline）是一种强大的数据处理工具，它允许用户对集合中的文档执行一系列数据转换和处理操作。聚合管道由一系列的阶段（stages）组成，每个阶段会对输入的文档进行一定的操作并将结果传递到下一个阶段。

每个阶段都是一个管道操作符（pipeline operator），共同组成一个管道。常见的管道操作符包括 $match、$group、$project、$sort、$limit 等。

聚合管道的基本结构
聚合管道通过 aggregate 方法来执行。其基本结构如下：

db.collection.aggregate([
    { $stage1: {...} },
    { $stage2: {...} },
    ...
])

常见聚合操作符

以下是一些常见的聚合操作符及其作用：

$match

用来过滤文档，其作用类似于 SQL 中的 WHERE 子句。

{ $match: { age: { $gte: 25 } } }

$group

将文档分组，并可以对每个分组应用聚合函数，如计数、求和、平均值等。

{ $group: { _id: "$age", count: { $sum: 1 } } }

$project

用于重新塑造文档，可以用来包括、排除或重命名字段。

{ $project: { name: 1, age: 1, _id: 0 } }

$sort

对文档进行排序。

{ $sort: { age: -1 } }

$limit

限制返回的文档数量。

{ $limit: 10 }

$skip

跳过指定数量的文档。

{ $skip: 5 }

$lookup

用于执行左外连接。

{ $lookup: { from: "otherCollection", localField: "fieldA", foreignField: "fieldB", as: "newField" } }

$unwind

将数组类型字段中的每个值拆分成单独的文档。

{ $unwind: "$arrayField" }

 示例

下面是一个使用 aggregate 方法的具体示例，展示了如何使用聚合管道操作符：

db.users.aggregate([
    // 匹配 age 大于等于 25 的文档
    { $match: { age: { $gte: 25 } } },
    // 按照 age 分组，并计算每个分组的数量
    { $group: { _id: "$age", count: { $sum: 1 } } },
    // 按照 count 字段降序排序
    { $sort: { count: -1 } },
    // 仅保留前 5 个结果
    { $limit: 5 }
])

Go中的聚合管道使用示例

package main

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

func main() {
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    defer func() {
        if err = client.Disconnect(ctx); err != nil {
            log.Fatal(err)
        }
    }()

    db := client.Database("testDB")
    collection := db.Collection("users")

    pipeline := mongo.Pipeline{
        {{Key: "$match", Value: map[string]interface{}{"age": map[string]interface{}{"$gte": 25}}}},
        {{Key: "$group", Value: map[string]interface{}{"_id": "$age", "count": map[string]interface{}{"$sum": 1}}}},
        {{Key: "$sort", Value: map[string]interface{}{"count": -1}}},
        {{Key: "$limit", Value: int32(5)}},
    }

    cursor, err := collection.Aggregate(ctx, pipeline)
    if err != nil {
        log.Fatal(err)
    }
    defer cursor.Close(ctx)

    var results []map[string]interface{}
    if err = cursor.All(ctx, &results); err != nil {
        log.Fatal(err)
    }

    for _, result := range results {
        log.Println(result)
    }
}
    pipeline := mongo.Pipeline{
        {{Key: "$match", Value: map[string]interface{}{"age": map[string]interface{}{"$gte": 25}}}},
        {{Key: "$group", Value: map[string]interface{}{"_id": "$age", "count": map[string]interface{}{"$sum": 1}}}},
    }

    cursor, err = collection.Aggregate(ctx, pipeline)
    if err != nil {
        log.Fatal(err)
    }
    defer cursor.Close(ctx)

    var pipelineResults []map[string]interface{}
    if err = cursor.All(ctx, &pipelineResults); err != nil {
        log.Fatal(err)
    }
    for _, result := range pipelineResults {
        log.Println(result)
    }

完整示例

package main

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

func main() {
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        log.Fatal(err)
    }
    
    defer func() {
        if err = client.Disconnect(ctx); err != nil {
            log.Fatal(err)
        }
    }()

    db := client.Database("testDB")
    collection := db.Collection("users")

    // 插入文档
    collection.InsertOne(ctx, map[string]interface{}{"name": "Alice", "age": 29})
    collection.InsertMany(ctx, []interface{}{
        map[string]interface{}{"name": "Bob", "age": 31},
        map[string]interface{}{"name": "Charlie", "age": 25},
    })

    // 查询单个文档
    var result map[string]interface{}
    collection.FindOne(ctx, map[string]interface{}{"name": "Alice"}).Decode(&result)
    log.Println(result)

    // 查询多个文档
    cursor, err := collection.Find(ctx, map[string]interface{}{"age": map[string]interface{}{"$gte": 30}})
    if err != nil {
        log.Fatal(err)
    }
    defer cursor.Close(ctx)

    var results []map[string]interface{}
    cursor.All(ctx, &results)
    for _, res := range results {
        log.Println(res)
    }

    // 更新文档
    collection.UpdateOne(ctx, map[string]interface{}{"name": "Bob"}, map[string]interface{}{"$set": map[string]interface{}{"age": 32}})
    collection.UpdateMany(ctx, map[string]interface{}{"age": map[string]interface{}{"$lt": 30}}, map[string]interface{}{"$set": map[string]interface{}{"valid": true}})
    
    // 删除文档
    collection.DeleteOne(ctx, map[string]interface{}{"name": "Charlie"})
    collection.DeleteMany(ctx, map[string]interface{}{"valid": true})
    
    // 聚合管道
    pipeline := mongo.Pipeline{
        {{Key: "$match", Value: map[string]interface{}{"age": map[string]interface{}{"$gte": 25}}}},
        {{Key: "$group", Value: map[string]interface{}{"_id": "$age", "count": map[string]interface{}{"$sum": 1}}}},
    }
    
    cursor, err = collection.Aggregate(ctx, pipeline)
    if err != nil {
        log.Fatal(err)
    }
    defer cursor.Close(ctx)
    
    var pipelineResults []map[string]interface{}
    cursor.All(ctx, &pipelineResults)
    for _, res := range pipelineResults {
        log.Println(res)
    }
}
特立独行的猫a
关注
  • 28
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
golang分布式中间件之mongodb
SMILY12138的博客
04-15 876
综上所述，golang分布式中间件之mongodb是一种强大的分布式系统解决方案，它可以为企业提供高可用性、高扩展性和灵活性的数据存储和查询服务。随着互联网的快速发展，分布式系统的需求也越来越强烈，因此如何通过分布式中间件实现MongoDB的分布式部署和高可用性成为了一个重要问题。分片集群是MongoDB中的一种扩展性解决方案，它将数据分片存储在不同的节点上，从而实现横向扩展。分布式中间件是指在分布式系统中运行的软件组件，它们提供了通信、协调和管理等功能，从而为分布式应用程序提供支持。
Go学习——使用MongoDB
脑袋装水的博客
04-03 6065
目录MongoDB添加mongodb依赖连接MongoDB:操作数据库CRUD操作插入文档插入单个文档插入多条文档更新文档更新单个文档更新多个文档查找文档查询单个文档：查询多个文档：删除文档 MongoDB MongoDB是一个高性能，开源，无模式的文档型数据库，是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，采用的是类似json的bjson格式来存储数据，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，
一文教你Go语言如何轻松使用MongoDB
weixin_59801183的博客
05-09 1615
本文档详细介绍了如何使用Go语言对MongoDB进行基础操作。我们将学习如何使用Go连接MongoDB、插入文档、查询文档、更新文档和删除文档。
Golang（go）+mongodb开发个人遇到坑及用法总结汇总
最新发布
justtest02的博客
08-30 988
Golang（go）+ mongodb开发个人遇到坑及用法总结汇总 用享
使用Golang连接MongoDB方法详解
路多辛的所思所想
04-17 1075
Golang连接MongoDB的库有很多，本文主要讲解使用MongoDB官方驱动 go.mongodb.org/mongo-driver/mongo 连接MongoDB的方法。接下来以标准连接字符串格式来做讲解。
Python操作mongodb数据库进行模糊查询操作示例
01-20
本文实例讲述了Python操作mongodb数据库进行模糊查询操作。分享给大家供大家参考，具体如下： # -*- coding: utf-8 -*- import pymongo import re from pymongo import MongoClient #创建连接 #10.20.66.106 client...
Golang Mongodb模糊查询的使用示例
09-09
主要给大家介绍了关于Golang Mongodb模糊查询的使用示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Python使用pymongo模块操作MongoDB的方法示例
01-20
本文实例讲述了Python使用pymongo模块操作MongoDB的方法。分享给大家供大家参考，具体如下： 通过pymongo实现python对Mongodb的操作。 具体看python代码 #!/usr/bin/python # coding=utf-8 #python实现对MongoDB的...
python连接mongodb操作数据示例(mongodb数据库配置类)
12-23
复制代码 代码如下:#encoding=utf-8”’Mongo Conn连接类”’import pymongoclass DBConn: conn = None servers = “mongodb://localhost:27017” def connect(self): self.conn = pymongo.Connection(self....
Android编程连接MongoDB及增删改查等基本操作示例
01-20
本文实例讲述了Android编程连接MongoDB及增删改查等基本操作。分享给大家供大家参考，具体如下： MongoDB简介 Mongodb，分布式文档存储数据库，由C++语言编写，旨在为WEB应用提供可扩展的高性能数据存储解决方案。...
golang简单封装使用mongodb
itxsl的博客
07-22 848
为在golang中使用mongodb简单快捷，对mongodb进行一些简单的封装。
Golang+MongoDB 从基础到放弃 进阶（二）
qq_25490573的博客
08-08 1127
这里写目录标题前言索引explain副本集 Replica Sets概念两种类型三种角色选举 前言 阅读本文需要查看前文 索引explain mongodb中的分析只需要执行语句的后面添加.explain() db.meituan.find({node_id:"2"}).explain() 返回的内容(json)并不适于查看，可以借助compass工具，可视化效果更佳 如下图 Documents Examined 查询到的文档个数 后面会提示索引使用情况 COLLSCAN 表示未命中索引，进行了全表
Go --- 简单操作MongoDB
weixin_52025712的博客
04-22 685
依赖包的选择： impor "go.mongodb.org/mongo-driver/mongo" go.mod中写入 require go.mongodb.org/mongo-driver v1.9.0 连接 简单连接 // 简单连接 func main() { clientOpts := options.Client().ApplyURI("mongodb://localhost:27017/?connect=direct") client, err := mongo.Connect(conte
go操作mongodb
无耻的鱼
05-04 837
Golang操作mongoDB 学习要与时俱进 现在使用的是mongo 库是"go.mongodb.org/mongo-driver/mongo" 不再是"github.com/mongodb/mongo-go-driver/mongo" package main import ( "context" "fmt" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/mongo" "go.mongod...
go操作MongoDB
一个菜鸟的博客
03-26 2927
MongoDB介绍 MongoDB是目前比较流行的一个基于分布式文件存储的数据库,它是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库中功能最丰富,最像关系数据库的 MongoDB中将一条数据储存为一个文档(document),数据结构由键值对(K-V)组成,其中文档类似于平常使用到的JSON对象,文档中的字段值可以包含其他文档,数组,及文档数组 insert package main import ( "context" "fmt" "go.mongodb.org/mongo-drive
Golang使用MongoDB通用操作
impressionw的博客
08-13 9780
       MongoDB是Nosql中常用的一种数据库，今天笔者就简单总结一下Golang如何使用这些通用的供能的，不喜勿喷。。。        研究的事例结构如下： type LikeBest struct { AuthorName string `bson:"authorname,omitempty"` BookName string `bson:"bo...
Go语言操作MongoDB
张音乐的博客
04-29 1261
package main import ( "fmt" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" ) type Person struct { Name string Phone string } func main() { session, err := mgo.Dial("127.0.0.1") if err != nil { ...
golang mongoDB 的集合创建以及增删改查操作
热门推荐
地球流浪猫的博客
04-12 1万+
mongo官方没有golang 的官方驱动，但是有一个社区驱动： http://labix.org/mgo api文档：https://godoc.org/gopkg.in/mgo.v2#Collection.Update 数据的连接操作请看的我的上一篇博客，本文重点介绍mgo的CURD操作及遇到的坑。 mog的文档可以不用特别的创建，在数据插入的时候，如果驱动发现文档不存在，会自动创建。...
go语言操作mongodb，怎么用事务回滚进行写入删除等
08-06
### 回答1： 在使用 Go 语言操作 MongoDB 数据库时，可以使用事务来管理写入、删除等操作。 首先，在开启事务之前，需要先获取一个 MongoDB 连接： ``` client, err := mongo.NewClient(options.Client().ApplyURI("mongodb://localhost:27017")) if err != nil { // handle error } ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second) defer cancel() err = client.Connect(ctx) if err != nil { // handle error } ``` 然后，可以使用 `client.Database()` 方法来获取数据库的句柄，再使用 `Database.StartSession()` 方法来开启一个事务： ``` sess, err := client.Database("mydb").StartSession() if err != nil { // handle error } defer sess.EndSession(ctx) ``` 在事务中执行写入、删除等操作时，需要使用 `Session.WithTransaction()` 方法来包裹这些操作，并使用 `Session.AbortTransaction()` 方法来回滚事务： ``` err = sess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) error { // perform write operations _, err = client.Database("mydb").Collection("mycoll").InsertOne(sessCtx, bson.M{"x": 1}) if err != nil { sess.AbortTransaction(sessCtx) return err } return nil }) if err != nil { // handle error } ``` 在事务中执行的所有操作都会在事务提交之前保存到内存中，并在事务提交时一起写入到数据库中。如果在事务中出现了错误，可以使用 `Session.AbortTransaction()` 方法来回滚事务，所有在事务中执行的操作都不会写入到数据库中。 在事务结 ### 回答2： 在Go语言中操作MongoDB，可以使用事务回滚来进行写入、删除等操作。以下是一些基本操作的示例： 1. 初始化MongoDB客户端和数据库连接： ```go clientOptions := options.Client().ApplyURI("mongodb://localhost:27017") client, err := mongo.Connect(context.TODO(), clientOptions) if err != nil { log.Fatal(err) } database := client.Database("mydatabase") ``` 2. 开启事务： ```go session, err := client.StartSession() if err != nil { log.Fatal(err) } defer session.EndSession(context.TODO()) ``` 3. 事务开始后，可以执行多个操作。例如，插入一条数据： ```go session.StartTransaction() collection := database.Collection("mycollection") doc := bson.D{{"key", "value"}} _, err = collection.InsertOne(session.Context(), doc) if err != nil { session.AbortTransaction(session.Context()) log.Fatal(err) } ``` 4. 执行其他操作，比如删除一条数据： ```go collection := database.Collection("mycollection") filter := bson.D{{"key", "value"}} _, err = collection.DeleteOne(session.Context(), filter) if err != nil { session.AbortTransaction(session.Context()) log.Fatal(err) } ``` 5. 若所有操作都成功执行，提交事务： ```go err = session.CommitTransaction(session.Context()) if err != nil { log.Fatal(err) } ``` 6. 若操作发生错误或者需要回滚，可以调用AbortTransaction()进行事务回滚： ```go session.AbortTransaction(session.Context()) ``` 以上是一个简单的示例，用于展示如何在Go语言中使用事务回滚进行写入和删除操作。实际应用中，可能需要更多的代码和逻辑来处理错误以及处理更复杂的事务操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

特立独行的猫a

您的鼓励是我的创作动力

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

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

打赏作者

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

抵扣说明：

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

余额充值