dtapps
/
go-library
1
0
Fork 0
Code Issues Pull Requests Projects Releases 40 Wiki Activity

- update dorm

Browse Source
master
李光春 2 years ago
parent 26bb5ccd2f
commit 79b3bb37e4
12 changed files with 491 additions and 472 deletions
Show Stats Download Patch File Download Diff File

12
utils/dorm/mongo.go
Unescape View File

@ -21,9 +21,10 @@ type ConfigMongoClient struct {
type MongoClient struct {
Db *mongo.Client // 驱动
config *ConfigMongoClient // 配置
databaseName string // 库名
collectionName string // 表名
filterArr []queryFilter // 查询条件数组
filter bson.D // 查询条件
//filterArr []queryFilter // 查询条件数组
filter bson.D // 查询条件
}
func NewMongoClient(config *ConfigMongoClient) (*MongoClient, error) {
@ -31,6 +32,8 @@ func NewMongoClient(config *ConfigMongoClient) (*MongoClient, error) {
var err error
c := &MongoClient{config: config}
c.databaseName = c.config.DatabaseName
// 连接到MongoDB
if c.config.Dns != "" {
c.Db, err = mongo.Connect(context.Background(), options.Client().ApplyURI(c.config.Dns))
@ -74,7 +77,10 @@ func NewMongoClientOfQmgo(config *ConfigMongoClient) (*MongoClient, error) {
return nil, errors.New(fmt.Sprintf("连接失败：%v", err))
}
log.Println(client)
db := client.Database("class")
coll := db.Collection("user")
log.Println(coll)
//coll.Find().One()
// 检查连接
err = c.Db.Ping(context.TODO(), nil)
if err != nil {

305
utils/dorm/mongo_curd.go
Unescape View File

@ -2,152 +2,219 @@ package dorm
import (
"context"
"errors"
"go.mongodb.org/mongo-driver/bson"
"log"
"reflect"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
// Database 设置库名
func (c *MongoClient) Database(databaseName string) *MongoClient {
c.setDatabaseName(databaseName)
return c
type InsertOneResult struct {
InsertedID interface{} // 插入的编号
}
// Collection 设置表名
func (c *MongoClient) Collection(collectionName string) *MongoClient {
c.setCollectionName(collectionName)
return c
// InsertOne 插入一个文档
func (c *MongoClient) InsertOne(document interface{}) (result *InsertOneResult, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
res, err := collection.InsertOne(context.TODO(), document)
return &InsertOneResult{InsertedID: res.InsertedID}, err
}
// Model 传入模型自动获取库名和表名
func (c *MongoClient) Model(value interface{}) *MongoClient {
// https://studygolang.com/articles/896
val := reflect.ValueOf(value)
if methodValue := val.MethodByName("Database"); methodValue.IsValid() {
c.setDatabaseName(methodValue.Call(nil)[0].String())
}
if methodValue := val.MethodByName("TableName"); methodValue.IsValid() {
c.setCollectionName(methodValue.Call(nil)[0].String())
type InsertManyResult struct {
InsertedIDs []interface{} // 插入的编号列表
}
// InsertMany 插入多个文档
func (c *MongoClient) InsertMany(documents []interface{}) (result *InsertManyResult, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
res, err := collection.InsertMany(context.TODO(), documents)
return &InsertManyResult{InsertedIDs: res.InsertedIDs}, err
}
// Delete 删除文档
func (c *MongoClient) Delete(filter interface{}) error {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
_, err := collection.DeleteOne(context.TODO(), filter)
return err
}
// DeleteId 删除文档
func (c *MongoClient) DeleteId(id interface{}) error {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
_, err := collection.DeleteOne(context.TODO(), bson.M{"_id": id})
return err
}
type DeleteResult struct {
DeletedCount int64 // 删除的数量
}
// DeleteMany 删除多个文档
func (c *MongoClient) DeleteMany(filter interface{}) (result *DeleteResult, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
res, err := collection.DeleteMany(context.TODO(), filter)
return &DeleteResult{DeletedCount: res.DeletedCount}, err
}
// UpdateOne 更新单个文档
// 修改字段的值($set)
// 字段增加值 inc($inc)
// 从数组中增加一个元素 push($push)
// 从数组中删除一个元素 pull($pull)
func (c *MongoClient) UpdateOne(filter interface{}, update interface{}) error {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
_, err := collection.UpdateOne(context.TODO(), filter, update)
return err
}
// UpdateId 更新单个文档
// 修改字段的值($set)
// 字段增加值 inc($inc)
// 从数组中增加一个元素 push($push)
// 从数组中删除一个元素 pull($pull)
func (c *MongoClient) UpdateId(id interface{}, update interface{}) error {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
_, err := collection.UpdateOne(context.TODO(), bson.M{"_id": id}, update)
return err
}
type UpdateResult struct {
MatchedCount int64 // The number of documents matched by the filter.
ModifiedCount int64 // The number of documents modified by the operation.
UpsertedCount int64 // The number of documents upserted by the operation.
UpsertedID interface{} // The _id field of the upserted document, or nil if no upsert was done.
}
// UpdateMany 更新多个文档
// 修改字段的值($set)
// 字段增加值 inc($inc)
// 从数组中增加一个元素 push($push)
// 从数组中删除一个元素 pull($pull)
func (c *MongoClient) UpdateMany(filter interface{}, update interface{}) (result *UpdateResult, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
res, err := collection.UpdateMany(context.TODO(), filter, update)
return &UpdateResult{
MatchedCount: res.MatchedCount,
ModifiedCount: res.ModifiedCount,
UpsertedCount: res.UpsertedCount,
UpsertedID: res.UpsertedID,
}, err
}
type FindResultI interface {
Many(result interface{}) error
}
// Find 查询
func (c *MongoClient) Find(filter interface{}) FindResultI {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
res, err := collection.Find(context.TODO(), filter)
return &FindResult{
cursor: res,
err: err,
}
return c
}
// CreateResult 返回查询结果
type CreateResult struct {
InsertedID interface{} // 创建一条记录的ID
InsertedIDs []interface{} // 创建多条记录的ID
}
// Create 创建数据
func (c *MongoClient) Create(values ...interface{}) (CreateResult, error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
const (
insertTypeOne = "one"
insertTypeMany = "many"
)
var (
insertType string
insertDataOne interface{}
insertDataMany []interface{}
)
for _, value := range values {
switch v := value.(type) {
case map[string]interface{}:
case []map[string]interface{}:
case map[string]string:
case []map[string]string:
default:
sliceValue := reflect.Indirect(reflect.ValueOf(value))
if sliceValue.Kind() == reflect.Slice {
insertType = insertTypeMany
size := sliceValue.Len()
for i := 0; i < size; i++ {
sv := sliceValue.Index(i) // 取出第i个元素
elemValue := sv.Interface() // 原始数据
insertDataMany = append(insertDataMany, elemValue) // 加入到数组中
}
} else {
insertType = insertTypeOne
insertDataOne = v
}
}
}
type FindOneResultI interface {
One(result interface{}) error
}
// FindOne 查询单个文档
func (c *MongoClient) FindOne(filter interface{}) FindOneResultI {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
res := collection.FindOne(context.TODO(), filter)
return &FindOneResult{
singleResult: res,
}
}
type FindManyResultI interface {
Many(result interface{}) error
}
if insertType == insertTypeOne {
result, err := collection.InsertOne(context.TODO(), insertDataOne)
return CreateResult{InsertedID: result.InsertedID}, err
} else if insertType == insertTypeMany {
result, err := collection.InsertMany(context.TODO(), insertDataMany)
return CreateResult{InsertedIDs: result.InsertedIDs}, err
} else {
return CreateResult{}, errors.New("values is empty")
// FindMany 查询多个文档
func (c *MongoClient) FindMany(filter interface{}) FindManyResultI {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
res, err := collection.Find(context.TODO(), filter)
return &FindManyResult{
cursor: res,
err: err,
}
}
// 查询条件
type queryFilter struct {
Key string
Value interface{}
// FindManyByFilters 多条件查询
func (c *MongoClient) FindManyByFilters(filter interface{}) (result *mongo.Cursor, err error) {
collection, err := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName).Clone()
result, err = collection.Find(context.TODO(), bson.M{"$and": filter})
return result, err
}
// Where 条件
func (c *MongoClient) Where(key string, value interface{}) *MongoClient {
log.Println("key", key)
log.Println("value", value)
c.filterArr = append(c.filterArr, queryFilter{key, value})
c.filter = bson.D{{key, value}}
return c
// FindManyByFiltersSort 多条件查询支持排序
func (c *MongoClient) FindManyByFiltersSort(filter interface{}, Sort interface{}) (result *mongo.Cursor, err error) {
collection, err := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName).Clone()
findOptions := options.Find()
findOptions.SetSort(Sort)
result, err = collection.Find(context.TODO(), filter, findOptions)
return result, err
}
// QueryResult 返回查询结果
type QueryResult struct {
RowsAffected int // 返回找到的记录数
Error error // 错误信息
// FindCollection 查询集合文档
func (c *MongoClient) FindCollection(Limit int64) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
findOptions := options.Find()
findOptions.SetLimit(Limit)
result, err = collection.Find(context.TODO(), bson.D{{}}, findOptions)
return result, err
}
// First 获取第一条记录（主键升序）
func (c *MongoClient) First() *QueryResult {
return &QueryResult{}
// FindCollectionSort 查询集合文档支持排序
func (c *MongoClient) FindCollectionSort(Sort interface{}, Limit int64) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
findOptions := options.Find()
findOptions.SetSort(Sort)
findOptions.SetLimit(Limit)
result, err = collection.Find(context.TODO(), bson.D{{}}, findOptions)
return result, err
}
// Take 获取一条记录，没有指定排序字段
func (c *MongoClient) Take(v interface{}) *QueryResult {
// FindManyCollectionSort 查询集合文档支持排序支持条件
func (c *MongoClient) FindManyCollectionSort(filter interface{}, Sort interface{}) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
//log.Printf("c.filterArr：%s\n", c.filterArr)
//log.Printf("c.filterArr：%v\n", c.filterArr)
//log.Printf("c.filterArr：%+v\n", c.filterArr)
//log.Printf("c.filter：%s\n", c.filter)
//log.Printf("c.filter：%v\n", c.filter)
//log.Printf("c.filter：%+v\n", c.filter)
err := collection.FindOne(context.TODO(), c.filter).Decode(v)
return &QueryResult{1, err}
findOptions := options.Find()
findOptions.SetSort(Sort)
result, err = collection.Find(context.TODO(), filter, findOptions)
return result, err
}
// Last 获取最后一条记录（主键降序）
func (c *MongoClient) Last() *QueryResult {
return &QueryResult{}
// CollectionCount 查询集合里有多少数据
func (c *MongoClient) CollectionCount() (name string, size int64) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
name = collection.Name()
size, _ = collection.EstimatedDocumentCount(context.TODO())
return name, size
}
// Find 获取多条记录
func (c *MongoClient) Find(v interface{}) *QueryResult {
// CollectionDocuments 按选项查询集合
// Skip 跳过
// Limit 读取数量
// sort 1 ，-1 . 1 为升序 ， -1 为降序
func (c *MongoClient) CollectionDocuments(Skip, Limit int64, sort int, key string, value interface{}) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
log.Printf("c.filterArr：%s\n", c.filterArr)
log.Printf("c.filterArr：%v\n", c.filterArr)
log.Printf("c.filterArr：%+v\n", c.filterArr)
log.Printf("c.filter：%s\n", c.filter)
log.Printf("c.filter：%v\n", c.filter)
log.Printf("c.filter：%+v\n", c.filter)
cursor, err := collection.Find(context.TODO(), c.filter)
if err != nil {
return &QueryResult{0, err}
}
SORT := bson.D{{"_id", sort}}
filter := bson.D{{key, value}}
findOptions := options.Find().SetSort(SORT).SetLimit(Limit).SetSkip(Skip)
result, err = collection.Find(context.TODO(), filter, findOptions)
return result, err
}
// 结果遍历和赋值
err = cursor.All(context.TODO(), v)
// AggregateByFiltersSort 统计分析
func (c *MongoClient) AggregateByFiltersSort(pipeline interface{}) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result, err = collection.Aggregate(context.TODO(), pipeline)
return result, err
}
return &QueryResult{cursor.RemainingBatchLength(), err}
// CountDocumentsByFilters 统计数量
func (c *MongoClient) CountDocumentsByFilters(filter interface{}) (count int64, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
count, err = collection.CountDocuments(context.TODO(), filter)
return count, err
}

15
utils/dorm/mongo_curl_find.go
Unescape View File

@ -0,0 +1,15 @@
package dorm
import (
"context"
"go.mongodb.org/mongo-driver/mongo"
)
type FindResult struct {
cursor *mongo.Cursor
err error
}
func (f *FindResult) Many(result interface{}) error {
return f.cursor.All(context.TODO(), result)
}

15
utils/dorm/mongo_curl_find_many.go
Unescape View File

@ -0,0 +1,15 @@
package dorm
import (
"context"
"go.mongodb.org/mongo-driver/mongo"
)
type FindManyResult struct {
cursor *mongo.Cursor
err error
}
func (f *FindManyResult) Many(result interface{}) error {
return f.cursor.All(context.TODO(), result)
}

11
utils/dorm/mongo_curl_find_one.go
Unescape View File

@ -0,0 +1,11 @@
package dorm
import "go.mongodb.org/mongo-driver/mongo"
type FindOneResult struct {
singleResult *mongo.SingleResult
}
func (f *FindOneResult) One(result interface{}) error {
return f.singleResult.Decode(result)
}

5
utils/dorm/mongo_get.go
Unescape View File

@ -2,14 +2,17 @@ package dorm
import "go.mongodb.org/mongo-driver/mongo"
// GetDb 获取驱动
func (c *MongoClient) GetDb() *mongo.Client {
return c.Db
}
// 获取库名
func (c *MongoClient) getDatabaseName() string {
return c.config.DatabaseName
return c.databaseName
}
// 获取表名
func (c *MongoClient) getCollectionName() string {
return c.collectionName
}

159
utils/dorm/mongo_official.go
Unescape View File

@ -1,159 +0,0 @@
package dorm
import (
"context"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
// InsertOne 插入单个文档
func (c *MongoClient) InsertOne(document interface{}) (result *mongo.InsertOneResult, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result, err = collection.InsertOne(context.TODO(), document)
return result, err
}
// InsertMany 插入多个文档
func (c *MongoClient) InsertMany(documents []interface{}) (result *mongo.InsertManyResult, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result, err = collection.InsertMany(context.TODO(), documents)
return result, err
}
// Delete 删除文档
func (c *MongoClient) Delete(filter interface{}) (int64, error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
count, err := collection.DeleteOne(context.TODO(), filter)
return count.DeletedCount, err
}
// DeleteMany 删除多个文档
func (c *MongoClient) DeleteMany(key string, value interface{}) (int64, error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
filter := bson.D{{key, value}}
count, err := collection.DeleteMany(context.TODO(), filter)
return count.DeletedCount, err
}
// UpdateOne 更新单个文档
// 修改字段的值($set)
// 字段增加值 inc($inc)
// 从数组中增加一个元素 push($push)
// 从数组中删除一个元素 pull($pull)
func (c *MongoClient) UpdateOne(filter interface{}, update interface{}) (int64, error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result, err := collection.UpdateOne(context.TODO(), filter, update)
return result.UpsertedCount, err
}
// UpdateMany 更新多个文档
// 修改字段的值($set)
// 字段增加值 inc($inc)
// 从数组中增加一个元素 push($push)
// 从数组中删除一个元素 pull($pull)
func (c *MongoClient) UpdateMany(filter interface{}, update interface{}) (int64, error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result, err := collection.UpdateMany(context.TODO(), filter, update)
return result.UpsertedCount, err
}
// Find 查询
//func (c *MongoClient) Find(filter interface{}) (result *mongo.Cursor, err error) {
// collection := c.Db.Database(c.DatabaseName).Collection(c.collectionName)
// result, err = collection.Find(context.TODO(), filter)
// return result, err
//}
// FindOne 查询单个文档
func (c *MongoClient) FindOne(filter interface{}) (result *mongo.SingleResult) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result = collection.FindOne(context.TODO(), filter)
return result
}
// FindMany 查询多个文档
func (c *MongoClient) FindMany(filter interface{}) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result, err = collection.Find(context.TODO(), filter)
return result, err
}
// FindManyByFilters 多条件查询
func (c *MongoClient) FindManyByFilters(filter interface{}) (result *mongo.Cursor, err error) {
collection, err := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName).Clone()
result, err = collection.Find(context.TODO(), bson.M{"$and": filter})
return result, err
}
// FindManyByFiltersSort 多条件查询支持排序
func (c *MongoClient) FindManyByFiltersSort(filter interface{}, Sort interface{}) (result *mongo.Cursor, err error) {
collection, err := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName).Clone()
findOptions := options.Find()
findOptions.SetSort(Sort)
result, err = collection.Find(context.TODO(), filter, findOptions)
return result, err
}
// FindCollection 查询集合文档
func (c *MongoClient) FindCollection(Limit int64) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
findOptions := options.Find()
findOptions.SetLimit(Limit)
result, err = collection.Find(context.TODO(), bson.D{{}}, findOptions)
return result, err
}
// FindCollectionSort 查询集合文档支持排序
func (c *MongoClient) FindCollectionSort(Sort interface{}, Limit int64) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
findOptions := options.Find()
findOptions.SetSort(Sort)
findOptions.SetLimit(Limit)
result, err = collection.Find(context.TODO(), bson.D{{}}, findOptions)
return result, err
}
// FindManyCollectionSort 查询集合文档支持排序支持条件
func (c *MongoClient) FindManyCollectionSort(filter interface{}, Sort interface{}) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
findOptions := options.Find()
findOptions.SetSort(Sort)
result, err = collection.Find(context.TODO(), filter, findOptions)
return result, err
}
// CollectionCount 查询集合里有多少数据
func (c *MongoClient) CollectionCount() (name string, size int64) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
name = collection.Name()
size, _ = collection.EstimatedDocumentCount(context.TODO())
return name, size
}
// CollectionDocuments 按选项查询集合
// Skip 跳过
// Limit 读取数量
// sort 1 ，-1 . 1 为升序 ， -1 为降序
func (c *MongoClient) CollectionDocuments(Skip, Limit int64, sort int, key string, value interface{}) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
SORT := bson.D{{"_id", sort}}
filter := bson.D{{key, value}}
findOptions := options.Find().SetSort(SORT).SetLimit(Limit).SetSkip(Skip)
result, err = collection.Find(context.TODO(), filter, findOptions)
return result, err
}
// AggregateByFiltersSort 统计分析
func (c *MongoClient) AggregateByFiltersSort(pipeline interface{}) (result *mongo.Cursor, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
result, err = collection.Aggregate(context.TODO(), pipeline)
return result, err
}
// CountDocumentsByFilters 统计数量
func (c *MongoClient) CountDocumentsByFilters(filter interface{}) (count int64, err error) {
collection := c.Db.Database(c.getDatabaseName()).Collection(c.collectionName)
count, err = collection.CountDocuments(context.TODO(), filter)
return count, err
}

25
utils/dorm/mongo_set.go
Unescape View File

@ -1,9 +1,28 @@
package dorm
func (c *MongoClient) setDatabaseName(databaseName string) {
c.config.DatabaseName = databaseName
import "reflect"
// Database 设置库名
func (c *MongoClient) Database(databaseName string) *MongoClient {
c.databaseName = databaseName
return c
}
func (c *MongoClient) setCollectionName(collectionName string) {
// Collection 设置表名
func (c *MongoClient) Collection(collectionName string) *MongoClient {
c.collectionName = collectionName
return c
}
// Model 传入模型自动获取库名和表名
func (c *MongoClient) Model(value interface{}) *MongoClient {
// https://studygolang.com/articles/896
val := reflect.ValueOf(value)
if methodValue := val.MethodByName("Database"); methodValue.IsValid() {
c.databaseName = methodValue.Call(nil)[0].String()
}
if methodValue := val.MethodByName("TableName"); methodValue.IsValid() {
c.collectionName = methodValue.Call(nil)[0].String()
}
return c
}

187
utils/dorm/mongo_transaction.go
Unescape View File

@ -2,10 +2,7 @@ package dorm
import (
"context"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
"reflect"
)
type MongoTransaction struct {
@ -49,187 +46,3 @@ func (ms *MongoTransaction) Rollback() error {
func (ms *MongoTransaction) Commit() error {
return ms.startSession.CommitTransaction(context.Background())
}
// Database 设置库名
func (ms *MongoTransaction) Database(databaseName string) *MongoTransaction {
ms.databaseName = databaseName
return ms
}
// Collection 设置表名
func (ms *MongoTransaction) Collection(collectionName string) *MongoTransaction {
ms.collectionName = collectionName
return ms
}
// Model 传入模型自动获取库名和表名
func (ms *MongoTransaction) Model(value interface{}) *MongoTransaction {
// https://studygolang.com/articles/896
val := reflect.ValueOf(value)
if methodValue := val.MethodByName("Database"); methodValue.IsValid() {
ms.databaseName = methodValue.Call(nil)[0].String()
}
if methodValue := val.MethodByName("TableName"); methodValue.IsValid() {
ms.collectionName = methodValue.Call(nil)[0].String()
}
return ms
}
func (ms *MongoTransaction) getDatabaseName() string {
return ms.databaseName
}
func (ms *MongoTransaction) getCollectionName() string {
return ms.collectionName
}
// InsertOne 插入单个文档
func (ms *MongoTransaction) InsertOne(document interface{}) (result *mongo.InsertOneResult, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
result, err = collection.InsertOne(ms.Session, document)
return result, err
}
// InsertMany 插入多个文档
func (ms *MongoTransaction) InsertMany(documents []interface{}) (result *mongo.InsertManyResult, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
result, err = collection.InsertMany(ms.Session, documents)
return result, err
}
// Delete 删除文档
func (ms *MongoTransaction) Delete(filter interface{}) (int64, error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
count, err := collection.DeleteOne(ms.Session, filter)
return count.DeletedCount, err
}
// DeleteMany 删除多个文档
func (ms *MongoTransaction) DeleteMany(key string, value interface{}) (int64, error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
filter := bson.D{{key, value}}
count, err := collection.DeleteMany(ms.Session, filter)
return count.DeletedCount, err
}
// UpdateOne 更新单个文档
// 修改字段的值($set)
// 字段增加值 inc($inc)
// 从数组中增加一个元素 push($push)
// 从数组中删除一个元素 pull($pull)
func (ms *MongoTransaction) UpdateOne(filter interface{}, update interface{}) (int64, error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
result, err := collection.UpdateOne(ms.Session, filter, update)
return result.UpsertedCount, err
}
// UpdateMany 更新多个文档
// 修改字段的值($set)
// 字段增加值 inc($inc)
// 从数组中增加一个元素 push($push)
// 从数组中删除一个元素 pull($pull)
func (ms *MongoTransaction) UpdateMany(filter interface{}, update interface{}) (int64, error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
result, err := collection.UpdateMany(ms.Session, filter, update)
return result.UpsertedCount, err
}
// Find 查询
func (ms *MongoTransaction) Find(filter interface{}) (result *mongo.Cursor, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
result, err = collection.Find(ms.Session, filter)
return result, err
}
// FindOne 查询单个文档
func (ms *MongoTransaction) FindOne(filter interface{}) (result *mongo.SingleResult) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
result = collection.FindOne(ms.Session, filter)
return result
}
// FindMany 查询多个文档
func (ms *MongoTransaction) FindMany(filter interface{}) (result *mongo.Cursor, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
result, err = collection.Find(ms.Session, filter)
return result, err
}
// FindManyByFilters 多条件查询
func (ms *MongoTransaction) FindManyByFilters(filter interface{}) (result *mongo.Cursor, err error) {
collection, err := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName).Clone()
result, err = collection.Find(ms.Session, bson.M{"$and": filter})
return result, err
}
// FindManyByFiltersSort 多条件查询支持排序
func (ms *MongoTransaction) FindManyByFiltersSort(filter interface{}, Sort interface{}) (result *mongo.Cursor, err error) {
collection, err := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName).Clone()
findOptions := options.Find()
findOptions.SetSort(Sort)
result, err = collection.Find(ms.Session, filter, findOptions)
return result, err
}
// FindCollection 查询集合文档
func (ms *MongoTransaction) FindCollection(Limit int64) (result *mongo.Cursor, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
findOptions := options.Find()
findOptions.SetLimit(Limit)
result, err = collection.Find(ms.Session, bson.D{{}}, findOptions)
return result, err
}
// FindCollectionSort 查询集合文档支持排序
func (ms *MongoTransaction) FindCollectionSort(Sort interface{}, Limit int64) (result *mongo.Cursor, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
findOptions := options.Find()
findOptions.SetSort(Sort)
findOptions.SetLimit(Limit)
result, err = collection.Find(ms.Session, bson.D{{}}, findOptions)
return result, err
}
// FindManyCollectionSort 查询集合文档支持排序支持条件
func (ms *MongoTransaction) FindManyCollectionSort(filter interface{}, Sort interface{}) (result *mongo.Cursor, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
findOptions := options.Find()
findOptions.SetSort(Sort)
result, err = collection.Find(ms.Session, filter, findOptions)
return result, err
}
// CollectionCount 查询集合里有多少数据
func (ms *MongoTransaction) CollectionCount(ctx context.Context) (name string, size int64) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
name = collection.Name()
size, _ = collection.EstimatedDocumentCount(ctx)
return name, size
}
// CollectionDocuments 按选项查询集合
// Skip 跳过
// Limit 读取数量
// sort 1 ，-1 . 1 为升序 ， -1 为降序
func (ms *MongoTransaction) CollectionDocuments(Skip, Limit int64, sort int, key string, value interface{}) (result *mongo.Cursor, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
SORT := bson.D{{"_id", sort}}
filter := bson.D{{key, value}}
findOptions := options.Find().SetSort(SORT).SetLimit(Limit).SetSkip(Skip)
result, err = collection.Find(ms.Session, filter, findOptions)
return result, err
}
// AggregateByFiltersSort 统计分析
func (ms *MongoTransaction) AggregateByFiltersSort(pipeline interface{}) (result *mongo.Cursor, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
result, err = collection.Aggregate(ms.Session, pipeline)
return result, err
}
// CountDocumentsByFilters 统计数量
func (ms *MongoTransaction) CountDocumentsByFilters(filter interface{}) (count int64, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
count, err = collection.CountDocuments(ms.Session, filter)
return count, err
}

190
utils/dorm/mongo_transaction_curd.go
Unescape View File

@ -0,0 +1,190 @@
package dorm
import (
"context"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
// InsertOne 插入一个文档
func (ms *MongoTransaction) InsertOne(document interface{}) (result *InsertOneResult, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
res, err := collection.InsertOne(ms.Session, document)
return &InsertOneResult{InsertedID: res.InsertedID}, err
}
// InsertMany 插入多个文档
func (ms *MongoTransaction) InsertMany(documents []interface{}) (result *InsertManyResult, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
res, err := collection.InsertMany(ms.Session, documents)
return &InsertManyResult{InsertedIDs: res.InsertedIDs}, err
}
// Delete 删除文档
func (ms *MongoTransaction) Delete(filter interface{}) error {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
_, err := collection.DeleteOne(ms.Session, filter)
return err
}
// DeleteId 删除文档
func (ms *MongoTransaction) DeleteId(id interface{}) error {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
_, err := collection.DeleteOne(ms.Session, bson.M{"_id": id})
return err
}
// DeleteMany 删除多个文档
func (ms *MongoTransaction) DeleteMany(key string, value interface{}) (result *DeleteResult, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
filter := bson.D{{key, value}}
res, err := collection.DeleteMany(ms.Session, filter)
return &DeleteResult{DeletedCount: res.DeletedCount}, err
}
// UpdateOne 更新单个文档
// 修改字段的值($set)
// 字段增加值 inc($inc)
// 从数组中增加一个元素 push($push)
// 从数组中删除一个元素 pull($pull)
func (ms *MongoTransaction) UpdateOne(filter interface{}, update interface{}) error {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
_, err := collection.UpdateOne(ms.Session, filter, update)
return err
}
// UpdateId 更新单个文档
// 修改字段的值($set)
// 字段增加值 inc($inc)
// 从数组中增加一个元素 push($push)
// 从数组中删除一个元素 pull($pull)
func (ms *MongoTransaction) UpdateId(id interface{}, update interface{}) error {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
_, err := collection.UpdateOne(context.TODO(), bson.M{"_id": id}, update)
return err
}
// UpdateMany 更新多个文档
// 修改字段的值($set)
// 字段增加值 inc($inc)
// 从数组中增加一个元素 push($push)
// 从数组中删除一个元素 pull($pull)
func (ms *MongoTransaction) UpdateMany(filter interface{}, update interface{}) (result *UpdateResult, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
res, err := collection.UpdateMany(ms.Session, filter, update)
return &UpdateResult{
MatchedCount: res.MatchedCount,
ModifiedCount: res.ModifiedCount,
UpsertedCount: res.UpsertedCount,
UpsertedID: res.UpsertedID,
}, err
}
// Find 查询
func (ms *MongoTransaction) Find(filter interface{}) FindResultI {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
res, err := collection.Find(ms.Session, filter)
return &FindResult{
cursor: res,
err: err,
}
}
// FindOne 查询单个文档
func (ms *MongoTransaction) FindOne(filter interface{}) FindOneResultI {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
res := collection.FindOne(ms.Session, filter)
return &FindOneResult{
singleResult: res,
}
}
// FindMany 查询多个文档
func (ms *MongoTransaction) FindMany(filter interface{}) FindManyResultI {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
res, err := collection.Find(ms.Session, filter)
return &FindManyResult{
cursor: res,
err: err,
}
}
// FindManyByFilters 多条件查询
func (ms *MongoTransaction) FindManyByFilters(filter interface{}) (result *mongo.Cursor, err error) {
collection, err := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName).Clone()
result, err = collection.Find(ms.Session, bson.M{"$and": filter})
return result, err
}
// FindManyByFiltersSort 多条件查询支持排序
func (ms *MongoTransaction) FindManyByFiltersSort(filter interface{}, Sort interface{}) (result *mongo.Cursor, err error) {
collection, err := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName).Clone()
findOptions := options.Find()
findOptions.SetSort(Sort)
result, err = collection.Find(ms.Session, filter, findOptions)
return result, err
}
// FindCollection 查询集合文档
func (ms *MongoTransaction) FindCollection(Limit int64) (result *mongo.Cursor, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
findOptions := options.Find()
findOptions.SetLimit(Limit)
result, err = collection.Find(ms.Session, bson.D{{}}, findOptions)
return result, err
}
// FindCollectionSort 查询集合文档支持排序
func (ms *MongoTransaction) FindCollectionSort(Sort interface{}, Limit int64) (result *mongo.Cursor, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
findOptions := options.Find()
findOptions.SetSort(Sort)
findOptions.SetLimit(Limit)
result, err = collection.Find(ms.Session, bson.D{{}}, findOptions)
return result, err
}
// FindManyCollectionSort 查询集合文档支持排序支持条件
func (ms *MongoTransaction) FindManyCollectionSort(filter interface{}, Sort interface{}) (result *mongo.Cursor, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
findOptions := options.Find()
findOptions.SetSort(Sort)
result, err = collection.Find(ms.Session, filter, findOptions)
return result, err
}
// CollectionCount 查询集合里有多少数据
func (ms *MongoTransaction) CollectionCount(ctx context.Context) (name string, size int64) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
name = collection.Name()
size, _ = collection.EstimatedDocumentCount(ctx)
return name, size
}
// CollectionDocuments 按选项查询集合
// Skip 跳过
// Limit 读取数量
// sort 1 ，-1 . 1 为升序 ， -1 为降序
func (ms *MongoTransaction) CollectionDocuments(Skip, Limit int64, sort int, key string, value interface{}) (result *mongo.Cursor, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
SORT := bson.D{{"_id", sort}}
filter := bson.D{{key, value}}
findOptions := options.Find().SetSort(SORT).SetLimit(Limit).SetSkip(Skip)
result, err = collection.Find(ms.Session, filter, findOptions)
return result, err
}
// AggregateByFiltersSort 统计分析
func (ms *MongoTransaction) AggregateByFiltersSort(pipeline interface{}) (result *mongo.Cursor, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
result, err = collection.Aggregate(ms.Session, pipeline)
return result, err
}
// CountDocumentsByFilters 统计数量
func (ms *MongoTransaction) CountDocumentsByFilters(filter interface{}) (count int64, err error) {
collection := ms.db.Database(ms.getDatabaseName()).Collection(ms.collectionName)
count, err = collection.CountDocuments(ms.Session, filter)
return count, err
}

11
utils/dorm/mongo_transaction_get.go
Unescape View File

@ -0,0 +1,11 @@
package dorm
// 获取库名
func (ms *MongoTransaction) getDatabaseName() string {
return ms.databaseName
}
// 获取表名
func (ms *MongoTransaction) getCollectionName() string {
return ms.collectionName
}

28
utils/dorm/mongo_transaction_set.go
Unescape View File

@ -0,0 +1,28 @@
package dorm
import "reflect"
// Database 设置库名
func (ms *MongoTransaction) Database(databaseName string) *MongoTransaction {
ms.databaseName = databaseName
return ms
}
// Collection 设置表名
func (ms *MongoTransaction) Collection(collectionName string) *MongoTransaction {
ms.collectionName = collectionName
return ms
}
// Model 传入模型自动获取库名和表名
func (ms *MongoTransaction) Model(value interface{}) *MongoTransaction {
// https://studygolang.com/articles/896
val := reflect.ValueOf(value)
if methodValue := val.MethodByName("Database"); methodValue.IsValid() {
ms.databaseName = methodValue.Call(nil)[0].String()
}
if methodValue := val.MethodByName("TableName"); methodValue.IsValid() {
ms.collectionName = methodValue.Call(nil)[0].String()
}
return ms
}
Write Preview
Loading…
Cancel
Save