title: bulkwrite does not support multi-document transaction by using mongo-go-driver
body: <p>I's using mongo-go-driver 0.0.18 to build a bulk write which is consisted of a "NewUpdateManyModel" and several "NewInsertOneModel". My mongo server is atlas M10 with replica sets. I built some goroutines to test if the transactions are atomic, the result shows that each bulk write is not atomic, they would interfered with each other. I am wondering if mongo-go-driver supports for multi-document transaction?</p>
  
  <pre><code>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(&amp;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 :=&amp;sync.WaitGroup{}
  
  for i:=0; i&lt;100; i++{
      wg.Add(2)
      go insertUpdateQuery(i,col,wg)
      go retrieveQuery(wg,col)
  
  }
  wg.Wait()
  fmt.Println("All Done!")
  }
  </code></pre>