Claude Opus 5
@@ -0,0 +1,392 @@
|
||||
package db
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"time"
|
||||
|
||||
"91porn-server/common/log"
|
||||
"91porn-server/common/stderr"
|
||||
|
||||
"go.mongodb.org/mongo-driver/bson"
|
||||
"go.mongodb.org/mongo-driver/bson/primitive"
|
||||
"go.mongodb.org/mongo-driver/mongo"
|
||||
"go.mongodb.org/mongo-driver/mongo/options"
|
||||
)
|
||||
|
||||
var (
|
||||
enableSortMCheck = true
|
||||
bsonDType = reflect.TypeOf(bson.D{})
|
||||
bsonDPtrType = reflect.TypeOf(&bson.D{})
|
||||
bsonEType = reflect.TypeOf(bson.E{})
|
||||
bsonEPtrType = reflect.TypeOf(&bson.E{})
|
||||
bsonMType = reflect.TypeOf(bson.M{})
|
||||
bsonMPtrType = reflect.TypeOf(&bson.M{})
|
||||
)
|
||||
|
||||
var skipErrors = []error{mongo.ErrNoDocuments}
|
||||
|
||||
func handleDbError(err error) error {
|
||||
for _, e := range skipErrors {
|
||||
if err == e {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
if err != nil {
|
||||
if mongo.IsDuplicateKeyError(err) {
|
||||
return stderr.InsertExistError
|
||||
}
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func sortCheck(sort interface{}) error {
|
||||
if !enableSortMCheck {
|
||||
return nil
|
||||
}
|
||||
if sort == nil {
|
||||
return nil
|
||||
}
|
||||
typ := reflect.TypeOf(sort)
|
||||
var m bson.M
|
||||
switch typ {
|
||||
case bsonMType:
|
||||
//log.Warn("mongo sort use bson.M use bson.D instead", log.Any("sort", sort))
|
||||
m, _ = sort.(bson.M)
|
||||
case bsonMPtrType:
|
||||
//log.Warn("mongo sort use *bson.M use bson.D instead", log.Any("sort", sort))
|
||||
pm, _ := sort.(*bson.M)
|
||||
m = *pm
|
||||
case bsonDType, bsonDPtrType, bsonEType, bsonEPtrType:
|
||||
return nil
|
||||
default:
|
||||
log.Warn("sort use unknown sort type please check", log.Any("sort", sort), log.Any("typ", typ))
|
||||
return errors.New("mongo error sort type")
|
||||
}
|
||||
if len(m) > 1 {
|
||||
return errors.New("mongo error sort, use bson.M and len(sort) > 1")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CreateIndex 创建数据索引.options 在index里面创建
|
||||
func (u *MongoTool) CreateIndex(models []mongo.IndexModel) ([]string, error) {
|
||||
//return nil, nil
|
||||
return u.coll.Indexes().CreateMany(u.ctx, models)
|
||||
}
|
||||
|
||||
// DropIndex 删除数据索引.options 在index里面创建
|
||||
func (u *MongoTool) DropIndex(indexname string) error {
|
||||
if _, err := u.coll.Indexes().DropOne(u.ctx, indexname); err != nil {
|
||||
log.Error(fmt.Sprintf("drop indexes error %+v", err))
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// DropIndexIfExists 删除指定索引；索引或所在集合尚未创建时均视为成功。
|
||||
func (u *MongoTool) DropIndexIfExists(indexname string) error {
|
||||
if _, err := u.coll.Indexes().DropOne(u.ctx, indexname); err != nil {
|
||||
var commandErr mongo.CommandError
|
||||
// 27=IndexNotFound(索引不存在)、26=NamespaceNotFound(集合/库尚未创建)：目标索引本就不存在，视为成功。
|
||||
if errors.As(err, &commandErr) && (commandErr.Code == 27 || commandErr.Code == 26) {
|
||||
return nil
|
||||
}
|
||||
log.Error(fmt.Sprintf("drop indexes error %+v", err))
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// InsertOne 插入单条信息
|
||||
func (u *MongoTool) InsertOne(document interface{}, opts ...*options.InsertOneOptions) (*mongo.InsertOneResult, error) {
|
||||
insertResult, err := u.coll.InsertOne(u.ctx, document, opts...)
|
||||
return insertResult, handleDbError(err)
|
||||
}
|
||||
|
||||
// InsertMany 批量插入信息
|
||||
func (u *MongoTool) InsertMany(documents interface{}, opts ...*options.InsertManyOptions) (*mongo.InsertManyResult, error) {
|
||||
if err := validInterfaceSlice(documents); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
res := setTimeForSlice(documents)
|
||||
return u.coll.InsertMany(u.ctx, res, opts...)
|
||||
}
|
||||
|
||||
// Find 查询多条数据
|
||||
func (u *MongoTool) Find(model interface{}, filter bson.M, opts ...*options.FindOptions) error {
|
||||
if err := validInterfaceSlice(model); err != nil {
|
||||
return err
|
||||
}
|
||||
cur, err := u.FindCursor(filter, opts...)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return handleDbError(cur.All(u.ctx, model))
|
||||
}
|
||||
|
||||
// FindCursor 查询多条数据并返回游标。
|
||||
// Cursor 不是并发安全的，调用方必须在完成或失败后关闭它。
|
||||
func (u *MongoTool) FindCursor(filter bson.M, opts ...*options.FindOptions) (*mongo.Cursor, error) {
|
||||
for _, opt := range opts {
|
||||
if opt == nil {
|
||||
continue
|
||||
}
|
||||
if opt.Limit != nil && *opt.Limit > 1000 {
|
||||
fmt.Println("limit beyond 1000 ==================>", *opt.Limit)
|
||||
}
|
||||
if opt.Sort != nil {
|
||||
if err := sortCheck(opt.Sort); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
}
|
||||
return u.coll.Find(u.ctx, filter, opts...)
|
||||
}
|
||||
|
||||
// FindOne 单条查询
|
||||
func (u *MongoTool) FindOne(model interface{}, filter bson.M, opts ...*options.FindOneOptions) error {
|
||||
for _, opt := range opts {
|
||||
if opt.Sort != nil {
|
||||
if err := sortCheck(opt.Sort); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return handleDbError(u.coll.FindOne(u.ctx, filter, opts...).Decode(model))
|
||||
}
|
||||
|
||||
// FindOneAndDelete 单条查询并删除
|
||||
func (u *MongoTool) FindOneAndDelete(model interface{}, filter bson.M, opts ...*options.FindOneAndDeleteOptions) error {
|
||||
for _, opt := range opts {
|
||||
if opt.Sort != nil {
|
||||
if err := sortCheck(opt.Sort); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return handleDbError(u.coll.FindOneAndDelete(u.ctx, filter, opts...).Decode(model))
|
||||
}
|
||||
|
||||
// FindOneAndReplace 单条查询 rd set to Before 表示返回原始数据, set to After 表示返回替换后的数据
|
||||
func (u *MongoTool) FindOneAndReplace(model interface{}, filter bson.M, replacement bson.M, opts ...*options.FindOneAndReplaceOptions) error {
|
||||
for _, opt := range opts {
|
||||
if opt.Sort != nil {
|
||||
if err := sortCheck(opt.Sort); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return handleDbError(u.coll.FindOneAndReplace(u.ctx, filter, replacement, opts...).Decode(model))
|
||||
}
|
||||
|
||||
// FindOneAndUpdate 单条查询 rd set to Before 表示返回原始数据, set to After 表示返回更新后的数据 默认为返回更新后的数据
|
||||
func (u *MongoTool) FindOneAndUpdate(model interface{}, filter bson.M, update bson.M, opts ...*options.FindOneAndUpdateOptions) error {
|
||||
for _, opt := range opts {
|
||||
if opt.Sort != nil {
|
||||
if err := sortCheck(opt.Sort); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
setReturn := false
|
||||
for _, opt := range opts {
|
||||
if opt != nil && opt.ReturnDocument != nil {
|
||||
setReturn = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !setReturn {
|
||||
after := options.After
|
||||
opts = append(opts, &options.FindOneAndUpdateOptions{ReturnDocument: &after})
|
||||
}
|
||||
return handleDbError(u.coll.FindOneAndUpdate(u.ctx, filter, update, opts...).Decode(model))
|
||||
}
|
||||
|
||||
// FindOneAndUpsert 单条查询 匹配到数据更新,未匹配到数据则upsert
|
||||
func (u *MongoTool) FindOneAndUpsert(model interface{}, filter bson.M, update bson.M, opts ...*options.FindOneAndUpdateOptions) error {
|
||||
upsert := true
|
||||
var beforeOrAfter options.ReturnDocument
|
||||
for _, opt := range opts {
|
||||
if opt.Sort != nil {
|
||||
if err := sortCheck(opt.Sort); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
setReturn := false
|
||||
for _, opt := range opts {
|
||||
if opt != nil && opt.ReturnDocument != nil {
|
||||
beforeOrAfter = *opt.ReturnDocument
|
||||
setReturn = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !setReturn {
|
||||
beforeOrAfter = options.After
|
||||
}
|
||||
opts = append(opts, &options.FindOneAndUpdateOptions{ReturnDocument: &beforeOrAfter, Upsert: &upsert})
|
||||
return handleDbError(u.coll.FindOneAndUpdate(u.ctx, filter, update, opts...).Decode(model))
|
||||
}
|
||||
|
||||
func (u *MongoTool) FindOneAndUpdateReturnTiny(bind interface{}, query bson.M, update bson.M, afterDoc bool, opts ...*options.FindOneAndUpdateOptions) error {
|
||||
if afterDoc {
|
||||
opts = append(opts, options.FindOneAndUpdate().SetReturnDocument(options.After))
|
||||
} else {
|
||||
opts = append(opts, options.FindOneAndUpdate().SetReturnDocument(options.Before))
|
||||
}
|
||||
result := handleDbError(u.coll.FindOneAndUpdate(u.ctx, query, update, opts...).Decode(bind))
|
||||
return result
|
||||
}
|
||||
|
||||
// FindOneByID 通过id查找一条数据
|
||||
func (u *MongoTool) FindOneByID(model interface{}, id primitive.ObjectID, opts ...*options.FindOneOptions) error {
|
||||
for _, opt := range opts {
|
||||
if opt.Sort != nil {
|
||||
if err := sortCheck(opt.Sort); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return handleDbError(u.coll.FindOne(u.ctx, bson.M{"_id": id}, opts...).Decode(model))
|
||||
}
|
||||
|
||||
// Aggregate 聚合查找数据
|
||||
func (u *MongoTool) Aggregate(model interface{}, pipeline []bson.M, opts ...*options.AggregateOptions) error {
|
||||
if err := validInterfaceSlice(model); err != nil {
|
||||
return err
|
||||
}
|
||||
cur, err := u.coll.Aggregate(u.ctx, pipeline, opts...)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return handleDbError(cur.All(u.ctx, model))
|
||||
}
|
||||
|
||||
// AggregateDecode 聚合.Decode
|
||||
func (u *MongoTool) AggregateDecode(model interface{}, pipeline []bson.M, opts ...*options.AggregateOptions) error {
|
||||
cur, err := u.coll.Aggregate(u.ctx, pipeline, opts...)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if cur.Next(u.ctx) {
|
||||
return handleDbError(cur.Decode(model))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Distinct 去重查询
|
||||
func (u *MongoTool) Distinct(fieldName string, filter bson.M, opts ...*options.DistinctOptions) ([]interface{}, error) {
|
||||
return u.coll.Distinct(u.ctx, fieldName, filter, opts...)
|
||||
}
|
||||
|
||||
// DeleteOne 删除一条数据
|
||||
func (u *MongoTool) DeleteOne(filter bson.M, opt ...*options.DeleteOptions) (*mongo.DeleteResult, error) {
|
||||
return u.coll.DeleteOne(u.ctx, filter, opt...)
|
||||
}
|
||||
|
||||
// DeleteMany 删除多条数据
|
||||
func (u *MongoTool) DeleteMany(filter bson.M, opt ...*options.DeleteOptions) (*mongo.DeleteResult, error) {
|
||||
return u.coll.DeleteMany(u.ctx, filter, opt...)
|
||||
}
|
||||
|
||||
// DeleteById 根据ID删除数据单条数据
|
||||
func (u *MongoTool) DeleteById(id primitive.ObjectID) (*mongo.DeleteResult, error) {
|
||||
return u.coll.DeleteOne(u.ctx, bson.M{"_id": id})
|
||||
}
|
||||
|
||||
// UpdateOne 更新单条数据
|
||||
func (u *MongoTool) UpdateOne(filter bson.M, update interface{}) (*mongo.UpdateResult, error) {
|
||||
return u.coll.UpdateOne(u.ctx, filter, update)
|
||||
}
|
||||
|
||||
// UpdateMany 修改多条数据
|
||||
func (u *MongoTool) UpdateMany(filter bson.M, update bson.M) (*mongo.UpdateResult, error) {
|
||||
return u.coll.UpdateMany(u.ctx, filter, update)
|
||||
}
|
||||
|
||||
// UpsertMany 或者修改或者插入多条数据
|
||||
func (u *MongoTool) UpsertMany(filter bson.M, update bson.M) (*mongo.UpdateResult, error) {
|
||||
return u.coll.UpdateMany(u.ctx, filter, update, options.Update().SetUpsert(true))
|
||||
}
|
||||
|
||||
// UpsertOne 或者修改或者插入一条数据
|
||||
func (u *MongoTool) UpsertOne(filter bson.M, update bson.M) (*mongo.UpdateResult, error) {
|
||||
return u.coll.UpdateOne(u.ctx, filter, update, options.Update().SetUpsert(true))
|
||||
}
|
||||
|
||||
// UpdateOneForSet 修改一条数据 【根据修改数据中集合类型字段】
|
||||
func (u *MongoTool) UpdateOneForSet(filter bson.M, update bson.D) (*mongo.UpdateResult, error) {
|
||||
return u.coll.UpdateOne(u.ctx, filter, update)
|
||||
}
|
||||
|
||||
// Count 获取数量
|
||||
func (u *MongoTool) Count(filter interface{}, opts ...*options.CountOptions) (int64, error) {
|
||||
if reflect.TypeOf(filter).Kind() == reflect.Slice {
|
||||
cur, err := u.coll.Aggregate(u.ctx, filter)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
var count int64 = 0
|
||||
for cur.Next(context.TODO()) {
|
||||
count++
|
||||
}
|
||||
return count, nil
|
||||
}
|
||||
return u.coll.CountDocuments(u.ctx, filter, opts...)
|
||||
}
|
||||
|
||||
// EstimateCount 获取数量
|
||||
func (u *MongoTool) EstimateCount(opts ...*options.EstimatedDocumentCountOptions) (int64, error) {
|
||||
return u.coll.EstimatedDocumentCount(u.ctx, opts...)
|
||||
}
|
||||
|
||||
// Bulk Bulk
|
||||
func (u *MongoTool) Bulk(models []mongo.WriteModel, opts ...*options.BulkWriteOptions) (*mongo.BulkWriteResult, error) {
|
||||
return u.coll.BulkWrite(u.ctx, models, opts...)
|
||||
}
|
||||
|
||||
// Exists 是否存在数据
|
||||
func (u *MongoTool) Exists(filter interface{}, opts ...*options.FindOneOptions) (bool, error) {
|
||||
var limit int64 = 1
|
||||
lo := &options.CountOptions{Limit: &limit}
|
||||
n, err := u.Count(filter, lo)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return n > 0, nil
|
||||
}
|
||||
|
||||
func setTimeForSlice(docs interface{}) []interface{} {
|
||||
arr := reflect.ValueOf(docs)
|
||||
if arr.Kind() == reflect.Ptr {
|
||||
arr = reflect.ValueOf(docs).Elem()
|
||||
}
|
||||
result := make([]interface{}, arr.Len())
|
||||
for i := 0; i < arr.Len(); i++ {
|
||||
ele := arr.Index(i)
|
||||
now := time.Now()
|
||||
if ma := ele.FieldByName("UpdatedAt"); ma.IsValid() {
|
||||
ma.Set(reflect.ValueOf(now))
|
||||
}
|
||||
if ca := ele.FieldByName("CreatedAt"); ca.IsValid() {
|
||||
ca.Set(reflect.ValueOf(now))
|
||||
}
|
||||
result[i] = ele.Interface()
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func validInterfaceSlice(bind interface{}) error {
|
||||
t := reflect.TypeOf(bind)
|
||||
k := t.Kind()
|
||||
if t.Kind() == reflect.Ptr {
|
||||
k = t.Elem().Kind()
|
||||
}
|
||||
if k != reflect.Slice {
|
||||
return stderr.MustSliceOrSlicePtr
|
||||
}
|
||||
return nil
|
||||
}
|
||||
Reference in New Issue
Block a user