137 lines
3.4 KiB
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 ©, e
|
|
case *mongo.UpdateOneModel:
|
|
copy := *m
|
|
v, e := c.taggedUpdate(m.Update)
|
|
copy.Update = v
|
|
return ©, e
|
|
case *mongo.UpdateManyModel:
|
|
copy := *m
|
|
v, e := c.taggedUpdate(m.Update)
|
|
copy.Update = v
|
|
return ©, 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
|
|
}
|