Merge pull request #92 from jiangz222/daily

new indexes operation

Author: jiangz222

README.md

@@ -96,7 +96,8 @@ var userInfo = UserInfo{
 Create index
 
 ```go
-cli.EnsureIndexes(ctx, []string{}, []string{"age", "name,weight"})
+cli.CreateOneIndex(context.Background(), options.IndexModel{Key: []string{"name"}, Unique: true})
+cli.CreateIndexes(context.Background(), []options.IndexModel{{Key: []string{"id2", "id3"}}})
 ```
 
 - Insert a document

README_ZH.md

@@ -92,7 +92,8 @@ var userInfo = UserInfo{
 创建索引
 
 ```go
-cli.EnsureIndexes(ctx, []string{}, []string{"age", "name,weight"})
+cli.CreateOneIndex(context.Background(), options.IndexModel{Key: []string{"name"}, Unique: true})
+cli.CreateIndexes(context.Background(), []options.IndexModel{{Key: []string{"id2", "id3"}}})
 ```
 
 - 插入一个文档

collection.go

@@ -3,16 +3,15 @@ package qmgo
 import (
 	"context"
 	"fmt"
-	"reflect"
-	"strings"
-
 	"github.com/qiniu/qmgo/field"
 	"github.com/qiniu/qmgo/hook"
 	opts "github.com/qiniu/qmgo/options"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 	"go.mongodb.org/mongo-driver/x/bsonx"
+	"reflect"
+	"strings"
 )
 
 // Collection is a handle to a MongoDB collection
@@ -294,77 +293,104 @@ func (c *Collection) Aggregate(ctx context.Context, pipeline interface{}) Aggreg
 // Example：indexes = []string{"idx1", "-idx2", "idx3,idx4"}
 // Three indexes will be created, index idx1 with ascending order, index idx2 with descending order, idex3 and idex4 are Compound ascending sort index
 // Reference: https://docs.mongodb.com/manual/reference/command/createIndexes/
-func (c *Collection) ensureIndex(ctx context.Context, indexes []string, isUnique bool) {
+func (c *Collection) ensureIndex(ctx context.Context, indexes []opts.IndexModel) error {
 	var indexModels []mongo.IndexModel
 
 	// 组建[]mongo.IndexModel
 	for _, idx := range indexes {
 		var model mongo.IndexModel
 		var keysDoc bsonx.Doc
 
-		colIndexArr := strings.Split(idx, ",")
-		for _, field := range colIndexArr {
+		for _, field := range idx.Key {
 			key, n := SplitSortField(field)
 
 			keysDoc = keysDoc.Append(key, bsonx.Int32(n))
 		}
-
+		iOptions := options.Index().SetUnique(idx.Unique).SetBackground(idx.Background).SetSparse(idx.Sparse)
+		if idx.ExpireAfterSeconds != nil {
+			iOptions.SetExpireAfterSeconds(*idx.ExpireAfterSeconds)
+		}
 		model = mongo.IndexModel{
 			Keys:    keysDoc,
-			Options: options.Index().SetUnique(isUnique),
+			Options: iOptions,
 		}
 
 		indexModels = append(indexModels, model)
 	}
 
 	if len(indexModels) == 0 {
-		return
+		return nil
 	}
 
-	var err error
-	var res []string
-	res, err = c.collection.Indexes().CreateMany(ctx, indexModels)
-
+	res, err := c.collection.Indexes().CreateMany(ctx, indexModels)
 	if err != nil || len(res) == 0 {
-		s := fmt.Sprint("<MongoDB.C>: ", c.collection.Name(), " Index: ", indexes, " error: ", err, "res: ", res)
-		panic(s)
+		fmt.Println("<MongoDB.C>: ", c.collection.Name(), " Index: ", indexes, " error: ", err, "res: ", res)
+		return err
 	}
-	return
+	return nil
 }
 
+// EnsureIndexes Deprecated
+// Recommend to use CreateIndexes / CreateOneIndex for more function)
 // EnsureIndexes creates unique and non-unique indexes in collection
-func (c *Collection) EnsureIndexes(ctx context.Context, uniques []string, indexes []string) {
-	// 创建唯一索引
-	if len(uniques) != 0 {
-		c.ensureIndex(ctx, uniques, true)
+// the combination of indexes is different from CreateIndexes:
+// if uniques/indexes is []string{"name"}, means create index "name"
+// if uniques/indexes is []string{"name,-age","uid"} means create Compound indexes: name and -age, then create one index: uid
+func (c *Collection) EnsureIndexes(ctx context.Context, uniques []string, indexes []string) (err error) {
+	uniqueModel, indexesModel := []opts.IndexModel{}, []opts.IndexModel{}
+	for _, v := range uniques {
+		vv := strings.Split(v, ",")
+		model := opts.IndexModel{Key: vv, Unique: true}
+		uniqueModel = append(uniqueModel, model)
+	}
+	if err = c.CreateIndexes(ctx, uniqueModel); err != nil {
+		return
 	}
 
-	// 创建普通索引
-	if len(indexes) != 0 {
-		c.ensureIndex(ctx, indexes, false)
+	for _, v := range indexes {
+		vv := strings.Split(v, ",")
+		model := opts.IndexModel{Key: vv}
+		indexesModel = append(uniqueModel, model)
+	}
+	if err = c.CreateIndexes(ctx, indexesModel); err != nil {
+		return
 	}
+	return
+}
 
+// CreateIndexes creates multiple indexes in collection
+// If the Key in opts.IndexModel is []string{"name"}, means create index: name
+// If the Key in opts.IndexModel is []string{"name","-age"} means create Compound indexes: name and -age
+func (c *Collection) CreateIndexes(ctx context.Context, indexes []opts.IndexModel) (err error) {
+	// 创建普通索引
+	err = c.ensureIndex(ctx, indexes)
 	return
 }
 
-// DropIndexes drop indexes in collection, indexes that be dropped should be in line with inputting indexes
-func (c *Collection) DropIndexes(ctx context.Context, indexes []string) error {
+// CreateIndex creates one index
+// If the Key in opts.IndexModel is []string{"name"}, means create index name
+// If the Key in opts.IndexModel is []string{"name","-age"} means drop Compound indexes: name and -age
+func (c *Collection) CreateOneIndex(ctx context.Context, indexes opts.IndexModel) error {
+	// 创建普通索引
+	return c.ensureIndex(ctx, []opts.IndexModel{indexes})
 
-	var err error
-	for _, index := range indexes {
-		_, err = c.collection.Indexes().DropOne(ctx, generateDroppedIndex(index))
-		if err != nil {
-			return err
-		}
+}
+
+// DropIndex drop indexes in collection, indexes that be dropped should be in line with inputting indexes
+// The indexes is []string{"name"} means drop index: name
+// The indexes is []string{"name","-age"} means drop Compound indexes: name and -age
+func (c *Collection) DropIndex(ctx context.Context, indexes []string) error {
+	_, err := c.collection.Indexes().DropOne(ctx, generateDroppedIndex(indexes))
+	if err != nil {
+		return err
 	}
 	return err
 }
 
-// generate indexes that store in mongo which may consist more than one index(like "index1,index2" is stored as "index1_1_index2_1")
-func generateDroppedIndex(index string) string {
+// generate indexes that store in mongo which may consist more than one index(like []string{"index1","index2"} is stored as "index1_1_index2_1")
+func generateDroppedIndex(index []string) string {
 	var res string
-	s := strings.Split(index, ",")
-	for _, e := range s {
+	for _, e := range index {
 		key, sort := SplitSortField(e)
 		n := key + "_" + fmt.Sprint(sort)
 		if len(res) == 0 {

collection_test.go

@@ -2,11 +2,13 @@ package qmgo
 
 import (
 	"context"
+	"github.com/qiniu/qmgo/options"
+	"testing"
+
 	"github.com/qiniu/qmgo/operator"
 	"github.com/stretchr/testify/require"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
-	"testing"
 )
 
 func TestCollection_EnsureIndex(t *testing.T) {
@@ -15,13 +17,13 @@ func TestCollection_EnsureIndex(t *testing.T) {
 	defer cli.Close(context.Background())
 	defer cli.DropCollection(context.Background())
 
-	cli.ensureIndex(context.Background(), nil, false)
-	cli.ensureIndex(context.Background(), []string{"id1"}, true)
-	cli.ensureIndex(context.Background(), []string{"id2,id3"}, false)
-	cli.ensureIndex(context.Background(), []string{"id4,-id5"}, false)
+	cli.ensureIndex(context.Background(), nil)
+	cli.ensureIndex(context.Background(), []options.IndexModel{{Key: []string{"id1"}, Unique: true}})
+	cli.ensureIndex(context.Background(), []options.IndexModel{{Key: []string{"id2", "id3"}}})
+	cli.ensureIndex(context.Background(), []options.IndexModel{{Key: []string{"id4", "-id5"}}})
 
-	// same index，panic
-	ast.Panics(func() { cli.ensureIndex(context.Background(), []string{"id1"}, false) })
+	// same index，error
+	ast.Error(cli.ensureIndex(context.Background(), []options.IndexModel{{Key: []string{"id1"}}}))
 
 	// check if unique indexs is working
 	var err error
@@ -47,8 +49,35 @@ func TestCollection_EnsureIndexes(t *testing.T) {
 	common := []string{"id2,id3", "id4,-id5"}
 	cli.EnsureIndexes(context.Background(), unique, common)
 
-	// same index，panic
-	ast.Panics(func() { cli.EnsureIndexes(context.Background(), nil, unique) })
+	// same index，error
+	ast.Error(cli.EnsureIndexes(context.Background(), nil, unique))
+
+	// check if unique indexs is working
+	var err error
+	doc := bson.M{
+		"id1": 1,
+	}
+
+	_, err = cli.InsertOne(context.Background(), doc)
+	ast.NoError(err)
+	_, err = cli.InsertOne(context.Background(), doc)
+	ast.Equal(true, IsDup(err))
+}
+
+func TestCollection_CreateIndexes(t *testing.T) {
+	ast := require.New(t)
+	cli := initClient("test")
+	defer cli.Close(context.Background())
+	defer cli.DropCollection(context.Background())
+
+	var expireS int32 = 100
+	unique := []string{"id1"}
+	ast.NoError(cli.CreateOneIndex(context.Background(), options.IndexModel{Key: unique, Unique: true, ExpireAfterSeconds: &expireS}))
+
+	ast.NoError(cli.CreateIndexes(context.Background(), []options.IndexModel{{Key: []string{"id2", "id3"}},
+		{Key: []string{"id4", "-id5"}}}))
+	// same index，error
+	ast.Error(cli.CreateOneIndex(context.Background(), options.IndexModel{Key: unique}))
 
 	// check if unique indexs is working
 	var err error
@@ -68,36 +97,36 @@ func TestCollection_DropIndex(t *testing.T) {
 	cli := initClient("test")
 	defer cli.DropCollection(context.Background())
 
-	cli.ensureIndex(context.Background(), []string{"index1"}, true)
+	cli.ensureIndex(context.Background(), []options.IndexModel{{Key: []string{"index1"}, Unique: true}})
 
-	// same index，panic
-	ast.Panics(func() { cli.ensureIndex(context.Background(), []string{"index1"}, false) })
+	// same index，error
+	ast.Error(cli.ensureIndex(context.Background(), []options.IndexModel{{Key: []string{"index1"}}}))
 
-	err := cli.DropIndexes(context.Background(), []string{"index1"})
+	err := cli.DropIndex(context.Background(), []string{"index1"})
 	ast.NoError(err)
-	ast.NotPanics(func() { cli.ensureIndex(context.Background(), []string{"index1"}, false) })
+	ast.NoError(cli.ensureIndex(context.Background(), []options.IndexModel{{Key: []string{"index1"}}}))
 
-	cli.ensureIndex(context.Background(), []string{"-index1"}, true)
-	// same index，panic
-	ast.Panics(func() { cli.ensureIndex(context.Background(), []string{"-index1"}, false) })
+	cli.ensureIndex(context.Background(), []options.IndexModel{{Key: []string{"-index1"}, Unique: true}})
+	// same index，error
+	ast.Error(cli.ensureIndex(context.Background(), []options.IndexModel{{Key: []string{"-index1"}}}))
 
-	err = cli.DropIndexes(context.Background(), []string{"-index1"})
+	err = cli.DropIndex(context.Background(), []string{"-index1"})
 	ast.NoError(err)
-	ast.NotPanics(func() { cli.ensureIndex(context.Background(), []string{"-index1"}, false) })
+	ast.NoError(cli.ensureIndex(context.Background(), []options.IndexModel{{Key: []string{"-index1"}}}))
 
-	err = cli.DropIndexes(context.Background(), []string{""})
+	err = cli.DropIndex(context.Background(), []string{""})
 	ast.Error(err)
 
-	err = cli.DropIndexes(context.Background(), []string{"index2"})
+	err = cli.DropIndex(context.Background(), []string{"index2"})
 	ast.Error(err)
 
-	cli.ensureIndex(context.Background(), []string{"index2,-index1"}, true)
-	ast.Panics(func() { cli.ensureIndex(context.Background(), []string{"index2,-index1"}, false) })
-	err = cli.DropIndexes(context.Background(), []string{"index2,-index1"})
+	cli.ensureIndex(context.Background(), []options.IndexModel{{Key: []string{"index2", "-index1"}, Unique: true}})
+	ast.Error(cli.ensureIndex(context.Background(), []options.IndexModel{{Key: []string{"index2", "-index1"}}}))
+	err = cli.DropIndex(context.Background(), []string{"index2", "-index1"})
 	ast.NoError(err)
-	ast.NotPanics(func() { cli.ensureIndex(context.Background(), []string{"index2,-index1"}, false) })
+	ast.NoError(cli.ensureIndex(context.Background(), []options.IndexModel{{Key: []string{"index2", "-index1"}}}))
 
-	err = cli.DropIndexes(context.Background(), []string{"-"})
+	err = cli.DropIndex(context.Background(), []string{"-"})
 	ast.Error(err)
 }
 

options/index_options.go

@@ -0,0 +1,9 @@
+package options
+
+type IndexModel struct {
+	Key                []string // Index key fields; prefix name with dash (-) for descending order
+	Unique             bool     // Prevent two documents from having the same index key
+	Background         bool     // Build index in background and return immediately
+	Sparse             bool     // Only index documents containing the Key fields
+	ExpireAfterSeconds *int32   // Periodically delete docs with indexed time.Time older than that.
+}