Mongodb bulkwrite不支持使用mongo go驱动程序进行多文档事务处理

我正在使用MongoGo驱动程序0.0.18构建一个大容量写入，它由一个“NewUpdateManyModel”和几个“NewInsertonModel”组成。我的mongo服务器是atlas M10，带有副本集。我构建了一些goroutine来测试事务是否是原子的，结果表明，每次批量写入都不是原子的，它们会相互干扰。我想知道mongo go驱动程序是否支持多文档事务

func insertUpdateQuery(counter int, col *mongo.Collection, group *sync.WaitGroup){
var operations []mongo.WriteModel
var items = []item{}
items=append(items,item{"Name":strconv.Itoa(counter),"Description":"latest one"})

for _,v := range items{
    operations = append(operations, mongo.NewInsertOneModel().Document(v))
}

updateOperation := mongo.NewUpdateManyModel()
updateOperation.Filter(bson.D{
    {"Name", bson.D{
        {"$ne", strconv.Itoa(counter)},
    }},
})
updateOperation.Update(bson.D{
    {"$set", bson.D{
        {"Description", strconv.Itoa(counter)},
    }},
},)
operations = append(operations,updateOperation)

bulkOps:=options.BulkWrite()
result, err := col.BulkWrite(
    context.Background(),
    operations,
    bulkOps,
)
if err != nil{
    fmt.Println("err:",err)
}else{
    fmt.Printf("IU: %+v \n",result)
}

group.Done()

}


func retrieveQuery(group *sync.WaitGroup, col *mongo.Collection){
var results []item
qctx:=context.Background()
qctx, c := context.WithTimeout(qctx, 10*time.Second)
defer c()
cur, err := col.Find(qctx, nil)
if err != nil {
    log.Fatal(err)
}
defer cur.Close(context.Background())
res := item{}
for cur.Next(context.Background()) {
    err := cur.Decode(&res)
    if err != nil {
        log.Println(err)
    }else {
        results=append(results,res)
    }
}
if err := cur.Err(); err != nil {
    log.Println(err)
}

fmt.Println("res:",results)

group.Done()
}



func main()  {
ctx := context.Background()
ctx, cancel := context.WithTimeout(ctx,10*time.Second)
defer cancel()

uri := "..."
client, err := mongo.NewClient(uri)
if err != nil {
    fmt.Printf("todo: couldn't connect to mongo: %v", err)
}
defer cancel()
err = client.Connect(ctx)
if err != nil {
    fmt.Printf("todo: mongo client couldn't connect with background context: %v", err)
}
col:=client.Database("jistest").Collection("Rules")

wg :=&sync.WaitGroup{}

for i:=0; i<100; i++{
    wg.Add(2)
    go insertUpdateQuery(i,col,wg)
    go retrieveQuery(wg,col)

}
wg.Wait()
fmt.Println("All Done!")
}

func insertUpdateQuery（计数器int，col*mongo.Collection，group*sync.WaitGroup）{
var操作[]mongo.WriteModel
var items=[]项{}
items=append（items，item{“Name”：strconv.Itoa（计数器），“Description:“latest one”}）
对于v，v:=范围项目{
operations=append（operations，mongo.NewInsertOneModel（）.Document（v））
}
updateOperation:=mongo.NewUpdateManyModel（）
updateOperation.Filter（bson.D{
{“名称”，bson.D{
{“$ne”，strconv.Itoa（柜台）}，
}},
})
updateOperation.Update（bson.D{
{“$set”，bson.D{
{“说明”，strconv.Itoa（计数器）}，
}},
},)
操作=追加（操作、更新操作）
bulkOps:=options.BulkWrite（）
结果，错误：=col.BulkWrite(
context.Background（），
操作，
散货船，
)
如果错误！=零{
fmt.Println（“错误：，错误）
}否则{
fmt.Printf（“IU:%+v\n”，结果）
}
组完成（）
}
func retrieveQuery（组*sync.WaitGroup，列*mongo.Collection）{
var结果[]项
qctx:=context.Background（）
qctx，c:=上下文，带超时（qctx，10*时间秒）
延迟c（）
cur，err:=列查找（qctx，无）
如果错误！=零{
log.Fatal（错误）
}
延迟当前关闭（context.Background（））
res:=项{}
对于cur.Next（context.Background（））{
错误：=当前解码（&res）
如果错误！=零{
log.Println（错误）
}否则{
结果=追加（结果、分辨率）
}
}
如果错误：=cur.err（）；错误！=nil{
log.Println（错误）
}
fmt.Println（“结果：”，结果）
组完成（）
}
func main（）{
ctx:=context.Background（）
ctx，cancel:=context.WithTimeout（ctx，10*time.Second）
推迟取消
uri:=“…”
客户端，错误：=mongo.NewClient（uri）
如果错误！=零{
fmt.Printf（“todo:无法连接到mongo:%v”，错误）
}
推迟取消
err=client.Connect（ctx）
如果错误！=零{
fmt.Printf（“todo:mongo客户端无法连接到后台上下文：%v”，错误）
}
col:=client.Database（“jistest”）.Collection（“规则”）
wg:=&sync.WaitGroup{}
对于i:=0；i
我想知道mongo go驱动程序是否支持多文档事务

func insertUpdateQuery(counter int, col *mongo.Collection, group *sync.WaitGroup){
var operations []mongo.WriteModel
var items = []item{}
items=append(items,item{"Name":strconv.Itoa(counter),"Description":"latest one"})

for _,v := range items{
    operations = append(operations, mongo.NewInsertOneModel().Document(v))
}

updateOperation := mongo.NewUpdateManyModel()
updateOperation.Filter(bson.D{
    {"Name", bson.D{
        {"$ne", strconv.Itoa(counter)},
    }},
})
updateOperation.Update(bson.D{
    {"$set", bson.D{
        {"Description", strconv.Itoa(counter)},
    }},
},)
operations = append(operations,updateOperation)

bulkOps:=options.BulkWrite()
result, err := col.BulkWrite(
    context.Background(),
    operations,
    bulkOps,
)
if err != nil{
    fmt.Println("err:",err)
}else{
    fmt.Printf("IU: %+v \n",result)
}

group.Done()

}


func retrieveQuery(group *sync.WaitGroup, col *mongo.Collection){
var results []item
qctx:=context.Background()
qctx, c := context.WithTimeout(qctx, 10*time.Second)
defer c()
cur, err := col.Find(qctx, nil)
if err != nil {
    log.Fatal(err)
}
defer cur.Close(context.Background())
res := item{}
for cur.Next(context.Background()) {
    err := cur.Decode(&res)
    if err != nil {
        log.Println(err)
    }else {
        results=append(results,res)
    }
}
if err := cur.Err(); err != nil {
    log.Println(err)
}

fmt.Println("res:",results)

group.Done()
}



func main()  {
ctx := context.Background()
ctx, cancel := context.WithTimeout(ctx,10*time.Second)
defer cancel()

uri := "..."
client, err := mongo.NewClient(uri)
if err != nil {
    fmt.Printf("todo: couldn't connect to mongo: %v", err)
}
defer cancel()
err = client.Connect(ctx)
if err != nil {
    fmt.Printf("todo: mongo client couldn't connect with background context: %v", err)
}
col:=client.Database("jistest").Collection("Rules")

wg :=&sync.WaitGroup{}

for i:=0; i<100; i++{
    wg.Add(2)
    go insertUpdateQuery(i,col,wg)
    go retrieveQuery(wg,col)

}
wg.Wait()
fmt.Println("All Done!")
}

不支持多文档事务（目前为beta版本0.1.0）

与会话关联。也就是说，您为会话启动一个事务。当使用任何MongoDB官方支持的驱动程序时，您必须向事务中的每个操作传递

您的示例似乎没有使用会话或事务。mongo go驱动程序（v0.1.0）中的多文档事务示例如下：

client, err := mongo.NewClient("<MONGODB URI>")
if err != nil { return err }
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
err = client.Connect(ctx)
if err != nil { return err }

session, err := client.StartSession()
database := client.Database("databaseName")
collection := database.Collection("collectionName")

err = mongo.WithSession(ctx, session, func(sctx mongo.SessionContext) error {
        // Start a transaction in the session 
        sctx.StartTransaction()

        var operations []mongo.WriteModel
        // Create an insert one operation
        operations = append(operations,
                            mongo.NewInsertOneModel().Document(
                            bson.D{{"Name", counter}, 
                                   {"Description", "latest"}}))

        // Create an update many operation
        updateOperation := mongo.NewUpdateManyModel()
        updateOperation.Filter(bson.D{{"Name", bson.D{
            {"$ne", counter},
        }}})
        updateOperation.Update(bson.D{
            {"$set", bson.D{
                {"Description", counter},
            }},
        })
        operations = append(operations, updateOperation)

        // Execute bulkWrite operation in a transactional session.
        _, err := collection.BulkWrite(sctx, operations)
        if err != nil {
            fmt.Println(err)
            return err
        }
        // Committing transaction
        session.CommitTransaction(sctx)
        return nil
})
session.EndSession(ctx)

我想知道mongo go驱动程序是否支持多文档事务

func insertUpdateQuery(counter int, col *mongo.Collection, group *sync.WaitGroup){
var operations []mongo.WriteModel
var items = []item{}
items=append(items,item{"Name":strconv.Itoa(counter),"Description":"latest one"})

for _,v := range items{
    operations = append(operations, mongo.NewInsertOneModel().Document(v))
}

updateOperation := mongo.NewUpdateManyModel()
updateOperation.Filter(bson.D{
    {"Name", bson.D{
        {"$ne", strconv.Itoa(counter)},
    }},
})
updateOperation.Update(bson.D{
    {"$set", bson.D{
        {"Description", strconv.Itoa(counter)},
    }},
},)
operations = append(operations,updateOperation)

bulkOps:=options.BulkWrite()
result, err := col.BulkWrite(
    context.Background(),
    operations,
    bulkOps,
)
if err != nil{
    fmt.Println("err:",err)
}else{
    fmt.Printf("IU: %+v \n",result)
}

group.Done()

}


func retrieveQuery(group *sync.WaitGroup, col *mongo.Collection){
var results []item
qctx:=context.Background()
qctx, c := context.WithTimeout(qctx, 10*time.Second)
defer c()
cur, err := col.Find(qctx, nil)
if err != nil {
    log.Fatal(err)
}
defer cur.Close(context.Background())
res := item{}
for cur.Next(context.Background()) {
    err := cur.Decode(&res)
    if err != nil {
        log.Println(err)
    }else {
        results=append(results,res)
    }
}
if err := cur.Err(); err != nil {
    log.Println(err)
}

fmt.Println("res:",results)

group.Done()
}



func main()  {
ctx := context.Background()
ctx, cancel := context.WithTimeout(ctx,10*time.Second)
defer cancel()

uri := "..."
client, err := mongo.NewClient(uri)
if err != nil {
    fmt.Printf("todo: couldn't connect to mongo: %v", err)
}
defer cancel()
err = client.Connect(ctx)
if err != nil {
    fmt.Printf("todo: mongo client couldn't connect with background context: %v", err)
}
col:=client.Database("jistest").Collection("Rules")

wg :=&sync.WaitGroup{}

for i:=0; i<100; i++{
    wg.Add(2)
    go insertUpdateQuery(i,col,wg)
    go retrieveQuery(wg,col)

}
wg.Wait()
fmt.Println("All Done!")
}

不支持多文档事务（目前为beta版本0.1.0）

与会话关联。也就是说，您为会话启动一个事务。当使用任何MongoDB官方支持的驱动程序时，您必须向事务中的每个操作传递

您的示例似乎没有使用会话或事务。mongo go驱动程序（v0.1.0）中的多文档事务示例如下：

client, err := mongo.NewClient("<MONGODB URI>")
if err != nil { return err }
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
err = client.Connect(ctx)
if err != nil { return err }

session, err := client.StartSession()
database := client.Database("databaseName")
collection := database.Collection("collectionName")

err = mongo.WithSession(ctx, session, func(sctx mongo.SessionContext) error {
        // Start a transaction in the session 
        sctx.StartTransaction()

        var operations []mongo.WriteModel
        // Create an insert one operation
        operations = append(operations,
                            mongo.NewInsertOneModel().Document(
                            bson.D{{"Name", counter}, 
                                   {"Description", "latest"}}))

        // Create an update many operation
        updateOperation := mongo.NewUpdateManyModel()
        updateOperation.Filter(bson.D{{"Name", bson.D{
            {"$ne", counter},
        }}})
        updateOperation.Update(bson.D{
            {"$set", bson.D{
                {"Description", counter},
            }},
        })
        operations = append(operations, updateOperation)

        // Execute bulkWrite operation in a transactional session.
        _, err := collection.BulkWrite(sctx, operations)
        if err != nil {
            fmt.Println(err)
            return err
        }
        // Committing transaction
        session.CommitTransaction(sctx)
        return nil
})
session.EndSession(ctx)