144 lines
3.4 KiB
Go
144 lines
3.4 KiB
Go
package repositoryimp
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
ri "git.sendico.io/tech/sxchnge/bff/pkg/db/repository/index"
|
|
"git.sendico.io/tech/sxchnge/bff/pkg/merrors"
|
|
"go.mongodb.org/mongo-driver/v2/bson"
|
|
"go.mongodb.org/mongo-driver/v2/mongo"
|
|
"go.mongodb.org/mongo-driver/v2/mongo/options"
|
|
)
|
|
|
|
func (r *MongoRepository) CreateIndex(def *ri.Definition) error {
|
|
if r.collection == nil {
|
|
return merrors.NoData("data collection is not set")
|
|
}
|
|
if len(def.Keys) == 0 {
|
|
return merrors.InvalidArgument("Index definition has no keys", "index.keys")
|
|
}
|
|
|
|
// ----- build BSON keys --------------------------------------------------
|
|
keys := bson.D{}
|
|
for _, k := range def.Keys {
|
|
var value any
|
|
switch {
|
|
case k.Type != "":
|
|
value = k.Type // text, 2dsphere, …
|
|
case k.Sort == ri.Desc:
|
|
value = int8(-1)
|
|
default:
|
|
value = int8(1) // default to Asc
|
|
}
|
|
keys = append(keys, bson.E{Key: k.Field, Value: value})
|
|
}
|
|
|
|
opts := options.Index().
|
|
SetUnique(def.Unique)
|
|
if def.TTL != nil {
|
|
opts.SetExpireAfterSeconds(*def.TTL)
|
|
}
|
|
if def.Name != "" {
|
|
opts.SetName(def.Name)
|
|
}
|
|
if def.PartialFilter != nil {
|
|
opts.SetPartialFilterExpression(def.PartialFilter.BuildQuery())
|
|
}
|
|
if def.Sparse {
|
|
opts.SetSparse(def.Sparse)
|
|
}
|
|
|
|
_, err := r.collection.Indexes().CreateOne(
|
|
context.Background(),
|
|
mongo.IndexModel{Keys: keys, Options: opts},
|
|
)
|
|
return err
|
|
}
|
|
|
|
func (r *MongoRepository) DropIndex(ctx context.Context, name string) error {
|
|
if r.collection == nil {
|
|
return merrors.NoData("data collection is not set")
|
|
}
|
|
if name == "" {
|
|
return merrors.InvalidArgument("index name is required", "index.name")
|
|
}
|
|
return r.collection.Indexes().DropOne(ctx, name)
|
|
}
|
|
|
|
func (r *MongoRepository) ListIndexDefinitions(ctx context.Context) ([]*ri.Definition, error) {
|
|
if r.collection == nil {
|
|
return nil, merrors.NoData("data collection is not set")
|
|
}
|
|
cursor, err := r.collection.Indexes().List(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() { _ = cursor.Close(ctx) }()
|
|
|
|
defs := make([]*ri.Definition, 0)
|
|
for cursor.Next(ctx) {
|
|
var doc mongoIndexDocument
|
|
if err := cursor.Decode(&doc); err != nil {
|
|
return nil, err
|
|
}
|
|
defs = append(defs, indexDefinitionFromDocument(doc))
|
|
}
|
|
if err := cursor.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return defs, nil
|
|
}
|
|
|
|
type mongoIndexDocument struct {
|
|
Name string `bson:"name"`
|
|
Key bson.D `bson:"key"`
|
|
Unique bool `bson:"unique"`
|
|
Sparse bool `bson:"sparse"`
|
|
ExpireAfterSeconds *int32 `bson:"expireAfterSeconds,omitempty"`
|
|
}
|
|
|
|
func indexDefinitionFromDocument(doc mongoIndexDocument) *ri.Definition {
|
|
keys := make([]ri.Key, 0, len(doc.Key))
|
|
for _, key := range doc.Key {
|
|
keys = append(keys, indexKeyFromBSON(key))
|
|
}
|
|
return &ri.Definition{
|
|
Keys: keys,
|
|
Unique: doc.Unique,
|
|
Sparse: doc.Sparse,
|
|
TTL: doc.ExpireAfterSeconds,
|
|
Name: doc.Name,
|
|
}
|
|
}
|
|
|
|
func indexKeyFromBSON(key bson.E) ri.Key {
|
|
out := ri.Key{Field: key.Key}
|
|
switch typed := key.Value.(type) {
|
|
case string:
|
|
out.Type = ri.IndexType(typed)
|
|
case int:
|
|
out.Sort = indexSort(typed)
|
|
case int8:
|
|
out.Sort = indexSort(typed)
|
|
case int16:
|
|
out.Sort = indexSort(typed)
|
|
case int32:
|
|
out.Sort = indexSort(typed)
|
|
case int64:
|
|
out.Sort = indexSort(typed)
|
|
case float64:
|
|
out.Sort = indexSort(typed)
|
|
default:
|
|
out.Type = ri.IndexType(fmt.Sprint(typed))
|
|
}
|
|
return out
|
|
}
|
|
|
|
func indexSort[T ~int | ~int8 | ~int16 | ~int32 | ~int64 | ~float64](value T) ri.Sort {
|
|
if value < 0 {
|
|
return ri.Desc
|
|
}
|
|
return ri.Asc
|
|
}
|