droboticflow/internal/store/query_sync_bulk.go

137 lines
3.4 KiB
Go

package store
import (
"context"
"errors"
"reflect"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
func (c *queryCollection) taggedModel(model mongo.WriteModel) (mongo.WriteModel, error) {
if model == nil || (reflect.ValueOf(model).Kind() == reflect.Pointer && reflect.ValueOf(model).IsNil()) {
return nil, errors.New("bulk model is nil")
}
switch m := model.(type) {
case *mongo.InsertOneModel:
copy := *m
v, e := c.taggedInsert(m.Document)
copy.Document = v
return &copy, e
case *mongo.UpdateOneModel:
copy := *m
v, e := c.taggedUpdate(m.Update)
copy.Update = v
return &copy, e
case *mongo.UpdateManyModel:
copy := *m
v, e := c.taggedUpdate(m.Update)
copy.Update = v
return &copy, e
case *mongo.ReplaceOneModel:
p, e := c.replacementPipeline(m.Replacement)
copy := mongo.NewUpdateOneModel().SetFilter(m.Filter).SetUpdate(p)
copy.Upsert = m.Upsert
copy.Collation = m.Collation
copy.Hint = m.Hint
return copy, e
default:
return model, nil
}
}
func (c *queryCollection) BulkWrite(ctx context.Context, models []mongo.WriteModel, opts ...*options.BulkWriteOptions) (*mongo.BulkWriteResult, error) {
if !c.tracks() {
return c.Collection.BulkWrite(ctx, models, opts...)
}
deletes := false
for _, m := range models {
if m == nil || (reflect.ValueOf(m).Kind() == reflect.Pointer && reflect.ValueOf(m).IsNil()) {
return nil, errors.New("bulk model is nil")
}
switch m.(type) {
case *mongo.DeleteOneModel, *mongo.DeleteManyModel:
deletes = true
}
}
if !deletes {
copy := make([]mongo.WriteModel, len(models))
for i, m := range models {
v, e := c.taggedModel(m)
if e != nil {
return nil, e
}
copy[i] = v
}
return c.Collection.BulkWrite(ctx, copy, opts...)
}
ordered := true
for _, v := range opts {
if v != nil && v.Ordered != nil {
ordered = *v.Ordered
}
}
result := &mongo.BulkWriteResult{UpsertedIDs: map[int64]any{}}
var failed mongo.BulkWriteException
for i, m := range models {
var err error
switch v := m.(type) {
case *mongo.DeleteOneModel:
o := options.Delete()
o.Collation = v.Collation
o.Hint = v.Hint
r, e := c.DeleteOne(ctx, v.Filter, o)
err = e
if r != nil {
result.DeletedCount += r.DeletedCount
}
case *mongo.DeleteManyModel:
o := options.Delete()
o.Collation = v.Collation
o.Hint = v.Hint
r, e := c.DeleteMany(ctx, v.Filter, o)
err = e
if r != nil {
result.DeletedCount += r.DeletedCount
}
default:
tagged, e := c.taggedModel(m)
err = e
if e == nil {
r, e := c.Collection.BulkWrite(ctx, []mongo.WriteModel{tagged}, opts...)
err = e
if r != nil {
result.InsertedCount += r.InsertedCount
result.MatchedCount += r.MatchedCount
result.ModifiedCount += r.ModifiedCount
result.DeletedCount += r.DeletedCount
result.UpsertedCount += r.UpsertedCount
for _, id := range r.UpsertedIDs {
result.UpsertedIDs[int64(i)] = id
}
}
}
}
if err != nil {
var bulk mongo.BulkWriteException
if !errors.As(err, &bulk) {
return result, err
}
for _, write := range bulk.WriteErrors {
write.Index = i
failed.WriteErrors = append(failed.WriteErrors, write)
}
if bulk.WriteConcernError != nil {
failed.WriteConcernError = bulk.WriteConcernError
}
if ordered {
break
}
}
}
if len(failed.WriteErrors) > 0 || failed.WriteConcernError != nil {
return result, failed
}
return result, nil
}