722 lines
17 KiB
Go
722 lines
17 KiB
Go
// =============================================================================
|
||
// Meilisearch 业务操作封装
|
||
// 提供CRUD操作方法，支持多数据源
|
||
// =============================================================================
|
||
|
||
package meilisearch
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"time"
|
||
|
||
"gitea.com/red-future/common/utils"
|
||
"github.com/gogf/gf/v2/container/gvar"
|
||
"github.com/gogf/gf/v2/errors/gerror"
|
||
"github.com/gogf/gf/v2/frame/g"
|
||
"github.com/gogf/gf/v2/os/glog"
|
||
"github.com/gogf/gf/v2/os/gtime"
|
||
"github.com/gogf/gf/v2/util/gconv"
|
||
ms "github.com/meilisearch/meilisearch-go"
|
||
)
|
||
|
||
// =============================================================================
|
||
// 向后兼容的Meilisearch结构体
|
||
// =============================================================================
|
||
|
||
type meilisearchDB struct {
|
||
noCache bool
|
||
dataSource string // 数据源名称，默认为 "default"
|
||
}
|
||
|
||
func DB(cache ...bool) *meilisearchDB {
|
||
return &meilisearchDB{
|
||
noCache: false,
|
||
dataSource: "default",
|
||
}
|
||
}
|
||
|
||
// WithDataSource 指定使用的数据源
|
||
func (m *meilisearchDB) WithDataSource(name string) *meilisearchDB {
|
||
m.dataSource = name
|
||
return m
|
||
}
|
||
|
||
// NoCache 不使用缓存
|
||
func (m *meilisearchDB) NoCache() *meilisearchDB {
|
||
m.noCache = true
|
||
return m
|
||
}
|
||
|
||
// =============================================================================
|
||
// 全局变量
|
||
// =============================================================================
|
||
|
||
var (
|
||
manager = GetManager()
|
||
)
|
||
|
||
const PageSize = 20
|
||
|
||
// =============================================================================
|
||
// Meilisearch 操作方法（支持多数据源）
|
||
// =============================================================================
|
||
|
||
// getDataSource 获取当前使用的数据源
|
||
func (m *meilisearchDB) getDataSource() (DataSource, error) {
|
||
if m.dataSource == "" {
|
||
m.dataSource = "default"
|
||
}
|
||
return manager.GetDataSource(m.dataSource)
|
||
}
|
||
|
||
// getClient 获取 Meilisearch 客户端
|
||
func (m *meilisearchDB) getClient() (interface{ Index(string) interface{} }, error) {
|
||
source, err := m.getDataSource()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if c, ok := source.Client().(interface{ Index(string) interface{} }); ok {
|
||
return c, nil
|
||
}
|
||
return nil, fmt.Errorf("invalid client type")
|
||
}
|
||
|
||
// indexInterface 辅助函数，获取index
|
||
func indexInterface(indexName string, client interface{ Index(string) interface{} }) interface{} {
|
||
return client.Index(indexName)
|
||
}
|
||
|
||
// buildSearchRequest 构建搜索请求
|
||
func (m *meilisearchDB) buildSearchRequest(ctx context.Context, searchParams *SearchParams) (*ms.SearchRequest, error) {
|
||
user, err := utils.GetUserInfo(ctx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
req := &ms.SearchRequest{
|
||
Limit: int64(PageSize),
|
||
Page: int64(0),
|
||
}
|
||
|
||
// 设置查询
|
||
if searchParams.Query != "" {
|
||
req.Query = searchParams.Query
|
||
}
|
||
|
||
// 设置分页
|
||
if searchParams.Page > 0 {
|
||
req.Page = int64(searchParams.Page - 1)
|
||
}
|
||
if searchParams.Limit > 0 {
|
||
req.Limit = int64(searchParams.Limit)
|
||
}
|
||
|
||
// 设置排序
|
||
if len(searchParams.Sort) > 0 {
|
||
req.Sort = searchParams.Sort
|
||
}
|
||
|
||
// 设置过滤条件（包含租户过滤和软删除过滤）
|
||
filter := ""
|
||
if !g.IsEmpty(user.TenantId) {
|
||
filter = fmt.Sprintf("tenantId = %s", gconv.String(user.TenantId))
|
||
}
|
||
if filter == "" {
|
||
filter = "isDeleted = false"
|
||
} else {
|
||
filter += " AND isDeleted = false"
|
||
}
|
||
|
||
// 添加用户自定义过滤条件
|
||
if searchParams.Filter != "" {
|
||
if filter == "" {
|
||
filter = searchParams.Filter
|
||
} else {
|
||
filter += " AND " + searchParams.Filter
|
||
}
|
||
}
|
||
|
||
if filter != "" {
|
||
req.Filter = filter
|
||
}
|
||
|
||
// 设置可搜索字段
|
||
if searchParams.SearchableAttributes != "" {
|
||
req.AttributesToSearchOn = []string{searchParams.SearchableAttributes}
|
||
}
|
||
|
||
// 设置返回字段
|
||
if len(searchParams.AttributesToRetrieve) > 0 {
|
||
req.AttributesToRetrieve = searchParams.AttributesToRetrieve
|
||
}
|
||
|
||
return req, nil
|
||
}
|
||
|
||
// Search 搜索文档
|
||
func (m *meilisearchDB) Search(ctx context.Context, searchParams *SearchParams, indexName string, result interface{}) (total int64, err error) {
|
||
client, err := m.getClient()
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
// 构建搜索请求
|
||
req, err := m.buildSearchRequest(ctx, searchParams)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
// Redis 缓存处理
|
||
user, err := utils.GetUserInfo(ctx)
|
||
if err != nil {
|
||
return
|
||
}
|
||
cacheKey := fmt.Sprintf("meilisearch:search:%s:%s:%+v", user.TenantId, indexName, searchParams)
|
||
if !m.noCache {
|
||
var resultStr *gvar.Var
|
||
resultStr, err = g.Redis().Get(ctx, cacheKey)
|
||
if err != nil {
|
||
return
|
||
}
|
||
if !g.IsEmpty(resultStr) {
|
||
searchResult := &SearchResult{}
|
||
if err = gconv.Struct(resultStr, searchResult); err != nil {
|
||
return
|
||
}
|
||
total = int64(searchResult.EstimatedTotalHits)
|
||
if len(searchResult.Hits) > 0 {
|
||
if resultArr, ok := result.(*[]map[string]interface{}); ok {
|
||
*resultArr = searchResult.Hits
|
||
} else {
|
||
err = gconv.Structs(searchResult.Hits, result)
|
||
if err != nil {
|
||
return
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
}
|
||
|
||
// 执行搜索
|
||
idx := indexInterface(indexName, client)
|
||
var searchResp *ms.SearchResponse
|
||
if i, ok := idx.(interface {
|
||
Search(string, *ms.SearchRequest) (*ms.SearchResponse, error)
|
||
}); ok {
|
||
searchResp, err = i.Search(searchParams.Query, req)
|
||
} else {
|
||
return 0, fmt.Errorf("index does not support Search method")
|
||
}
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
total = int64(searchResp.EstimatedTotalHits)
|
||
|
||
// 解析结果
|
||
if len(searchResp.Hits) > 0 {
|
||
hits := make([]map[string]interface{}, 0, len(searchResp.Hits))
|
||
for _, hit := range searchResp.Hits {
|
||
hitMap := gconv.Map(hit)
|
||
// 移除 Meilisearch 内部字段
|
||
delete(hitMap, "_formatted")
|
||
hits = append(hits, hitMap)
|
||
}
|
||
|
||
if resultArr, ok := result.(*[]map[string]interface{}); ok {
|
||
*resultArr = hits
|
||
} else {
|
||
err = gconv.Structs(hits, result)
|
||
if err != nil {
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
// 写入缓存
|
||
if !m.noCache {
|
||
hitList := make([]map[string]interface{}, 0)
|
||
if len(searchResp.Hits) > 0 {
|
||
for _, hit := range searchResp.Hits {
|
||
hitMap := gconv.Map(hit)
|
||
delete(hitMap, "_formatted")
|
||
hitList = append(hitList, hitMap)
|
||
}
|
||
}
|
||
searchResult := &SearchResult{
|
||
Hits: hitList,
|
||
EstimatedTotalHits: searchResp.EstimatedTotalHits,
|
||
Limit: int(searchResp.Limit),
|
||
Offset: int(searchResp.Offset),
|
||
ProcessingTimeMs: int(searchResp.ProcessingTimeMs),
|
||
}
|
||
err = g.Redis().SetEX(ctx, cacheKey, searchResult, int64(time.Hour))
|
||
if err != nil {
|
||
return
|
||
}
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
// Insert 插入文档
|
||
func (m *meilisearchDB) Insert(ctx context.Context, document interface{}, indexName string) (taskUID int64, err error) {
|
||
c, err := m.getClient()
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
user, err := utils.GetUserInfo(ctx)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
// 转换为 map
|
||
docMap := gconv.Map(document)
|
||
|
||
// 设置租户ID
|
||
if !g.IsEmpty(user.TenantId) && g.IsEmpty(docMap["tenantId"]) {
|
||
docMap["tenantId"] = user.TenantId
|
||
}
|
||
|
||
// 设置创建人
|
||
if !g.IsEmpty(user.UserName) && g.IsEmpty(docMap["creator"]) {
|
||
docMap["creator"] = user.UserName
|
||
}
|
||
|
||
// 设置更新人
|
||
if !g.IsEmpty(user.UserName) && g.IsEmpty(docMap["updater"]) {
|
||
docMap["updater"] = user.UserName
|
||
}
|
||
|
||
// 设置时间
|
||
now := gtime.Now().Time
|
||
if g.IsEmpty(docMap["createdAt"]) {
|
||
docMap["createdAt"] = now.Unix()
|
||
}
|
||
if g.IsEmpty(docMap["updatedAt"]) {
|
||
docMap["updatedAt"] = now.Unix()
|
||
}
|
||
|
||
// 设置删除标记
|
||
if g.IsEmpty(docMap["isDeleted"]) {
|
||
docMap["isDeleted"] = false
|
||
}
|
||
|
||
// 执行插入
|
||
documents := []map[string]interface{}{docMap}
|
||
idx := indexInterface(indexName, c)
|
||
var task *ms.TaskInfo
|
||
if i, ok := idx.(interface {
|
||
AddDocuments([]map[string]interface{}, interface{}) (*ms.TaskInfo, error)
|
||
}); ok {
|
||
task, err = i.AddDocuments(documents, nil)
|
||
} else {
|
||
return 0, fmt.Errorf("index does not support AddDocuments method")
|
||
}
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
// 清理缓存
|
||
err = m.cleanCache(ctx, indexName, user.TenantId)
|
||
if err != nil {
|
||
glog.Warning(ctx, "清理Redis缓存失败:", err)
|
||
}
|
||
|
||
return task.TaskUID, nil
|
||
}
|
||
|
||
// InsertMany 批量插入文档
|
||
func (m *meilisearchDB) InsertMany(ctx context.Context, documents []interface{}, indexName string) (taskUID int64, err error) {
|
||
c, err := m.getClient()
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
user, err := utils.GetUserInfo(ctx)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
docs := make([]map[string]interface{}, 0, len(documents))
|
||
for _, document := range documents {
|
||
docMap := gconv.Map(document)
|
||
|
||
// 设置租户ID
|
||
if !g.IsEmpty(user.TenantId) && g.IsEmpty(docMap["tenantId"]) {
|
||
docMap["tenantId"] = user.TenantId
|
||
}
|
||
|
||
// 设置创建人
|
||
if !g.IsEmpty(user.UserName) && g.IsEmpty(docMap["creator"]) {
|
||
docMap["creator"] = user.UserName
|
||
}
|
||
|
||
// 设置更新人
|
||
if !g.IsEmpty(user.UserName) && g.IsEmpty(docMap["updater"]) {
|
||
docMap["updater"] = user.UserName
|
||
}
|
||
|
||
// 设置时间
|
||
now := gtime.Now().Time
|
||
if g.IsEmpty(docMap["createdAt"]) {
|
||
docMap["createdAt"] = now.Unix()
|
||
}
|
||
if g.IsEmpty(docMap["updatedAt"]) {
|
||
docMap["updatedAt"] = now.Unix()
|
||
}
|
||
|
||
// 设置删除标记
|
||
if g.IsEmpty(docMap["isDeleted"]) {
|
||
docMap["isDeleted"] = false
|
||
}
|
||
|
||
docs = append(docs, docMap)
|
||
}
|
||
|
||
// 执行批量插入
|
||
idx := indexInterface(indexName, c)
|
||
var task *ms.TaskInfo
|
||
if i, ok := idx.(interface {
|
||
AddDocuments([]map[string]interface{}, interface{}) (*ms.TaskInfo, error)
|
||
}); ok {
|
||
task, err = i.AddDocuments(docs, nil)
|
||
} else {
|
||
return 0, fmt.Errorf("index does not support AddDocuments method")
|
||
}
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
// 清理缓存
|
||
err = m.cleanCache(ctx, indexName, user.TenantId)
|
||
if err != nil {
|
||
glog.Warning(ctx, "清理Redis缓存失败:", err)
|
||
}
|
||
|
||
return task.TaskUID, nil
|
||
}
|
||
|
||
// Update 更新文档
|
||
func (m *meilisearchDB) Update(ctx context.Context, document interface{}, indexName string) (taskUID int64, err error) {
|
||
c, err := m.getClient()
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
user, err := utils.GetUserInfo(ctx)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
// 转换为 map
|
||
docMap := gconv.Map(document)
|
||
|
||
// 设置更新人
|
||
if !g.IsEmpty(user.UserName) && g.IsEmpty(docMap["updater"]) {
|
||
docMap["updater"] = user.UserName
|
||
}
|
||
|
||
// 设置更新时间
|
||
docMap["updatedAt"] = gtime.Now().Unix()
|
||
|
||
// 执行更新
|
||
documents := []map[string]interface{}{docMap}
|
||
idx := indexInterface(indexName, c)
|
||
var task *ms.TaskInfo
|
||
if i, ok := idx.(interface {
|
||
UpdateDocuments([]map[string]interface{}, interface{}) (*ms.TaskInfo, error)
|
||
}); ok {
|
||
task, err = i.UpdateDocuments(documents, nil)
|
||
} else {
|
||
return 0, fmt.Errorf("index does not support UpdateDocuments method")
|
||
}
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
// 清理缓存
|
||
err = m.cleanCache(ctx, indexName, user.TenantId)
|
||
if err != nil {
|
||
glog.Warning(ctx, "清理Redis缓存失败:", err)
|
||
}
|
||
|
||
return task.TaskUID, nil
|
||
}
|
||
|
||
// Delete 删除文档
|
||
func (m *meilisearchDB) Delete(ctx context.Context, id string, indexName string) (taskUID int64, err error) {
|
||
c, err := m.getClient()
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
// 执行删除
|
||
idx := indexInterface(indexName, c)
|
||
var task *ms.TaskInfo
|
||
if i, ok := idx.(interface {
|
||
DeleteDocument(string) (*ms.TaskInfo, error)
|
||
}); ok {
|
||
task, err = i.DeleteDocument(id)
|
||
} else {
|
||
return 0, fmt.Errorf("index does not support DeleteDocument method")
|
||
}
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
// 清理缓存
|
||
user, err := utils.GetUserInfo(ctx)
|
||
if err != nil {
|
||
return
|
||
}
|
||
err = m.cleanCache(ctx, indexName, user.TenantId)
|
||
if err != nil {
|
||
glog.Warning(ctx, "清理Redis缓存失败:", err)
|
||
}
|
||
|
||
return task.TaskUID, nil
|
||
}
|
||
|
||
// DeleteSoft 软删除文档
|
||
func (m *meilisearchDB) DeleteSoft(ctx context.Context, id string, indexName string) (taskUID int64, err error) {
|
||
c, err := m.getClient()
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
user, err := utils.GetUserInfo(ctx)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
// 软删除：更新 isDeleted 字段
|
||
updateMap := map[string]interface{}{
|
||
"id": id,
|
||
"isDeleted": true,
|
||
"updater": user.UserName,
|
||
"updatedAt": gtime.Now().Unix(),
|
||
}
|
||
|
||
// 执行更新
|
||
documents := []map[string]interface{}{updateMap}
|
||
idx := indexInterface(indexName, c)
|
||
var task *ms.TaskInfo
|
||
if i, ok := idx.(interface {
|
||
UpdateDocuments([]map[string]interface{}, interface{}) (*ms.TaskInfo, error)
|
||
}); ok {
|
||
task, err = i.UpdateDocuments(documents, nil)
|
||
} else {
|
||
return 0, fmt.Errorf("index does not support UpdateDocuments method")
|
||
}
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
// 清理缓存
|
||
err = m.cleanCache(ctx, indexName, user.TenantId)
|
||
if err != nil {
|
||
glog.Warning(ctx, "清理Redis缓存失败:", err)
|
||
}
|
||
|
||
return task.TaskUID, nil
|
||
}
|
||
|
||
// Get 获取单个文档
|
||
func (m *meilisearchDB) Get(ctx context.Context, id string, indexName string, result interface{}) (err error) {
|
||
c, err := m.getClient()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
// Redis 缓存处理
|
||
user, err := utils.GetUserInfo(ctx)
|
||
if err != nil {
|
||
return
|
||
}
|
||
cacheKey := fmt.Sprintf("meilisearch:doc:%s:%s:%s", user.TenantId, indexName, id)
|
||
if !m.noCache {
|
||
var resultStr *gvar.Var
|
||
resultStr, err = g.Redis().Get(ctx, cacheKey)
|
||
if err != nil {
|
||
return
|
||
}
|
||
if !g.IsEmpty(resultStr) {
|
||
return gconv.Scan(resultStr, result)
|
||
}
|
||
}
|
||
|
||
// 执行查询
|
||
var doc map[string]interface{}
|
||
idx := indexInterface(indexName, c)
|
||
if i, ok := idx.(interface {
|
||
GetDocument(string, interface{}) error
|
||
}); ok {
|
||
err = i.GetDocument(id, &doc)
|
||
} else {
|
||
return fmt.Errorf("index does not support GetDocument method")
|
||
}
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
// 过滤已删除的文档
|
||
if gconv.Bool(doc["isDeleted"]) {
|
||
return gerror.New("文档不存在")
|
||
}
|
||
|
||
err = gconv.Struct(doc, result)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
// 写入缓存
|
||
if !m.noCache {
|
||
err = g.Redis().SetEX(ctx, cacheKey, result, int64(time.Hour))
|
||
if err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// cleanCache 清理缓存
|
||
func (m *meilisearchDB) cleanCache(ctx context.Context, indexName string, tenantId interface{}) error {
|
||
// 清理搜索缓存
|
||
searchKeys, err := g.Redis().Keys(ctx, fmt.Sprintf("meilisearch:search:%s:%s:*", tenantId, indexName))
|
||
if err != nil {
|
||
return err
|
||
}
|
||
for _, key := range searchKeys {
|
||
_, err = g.Redis().Del(ctx, key)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// CreateIndex 创建索引
|
||
func (m *meilisearchDB) CreateIndex(ctx context.Context, indexConfig *IndexConfig) (taskUID int64, err error) {
|
||
client, err := m.getClient()
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
indexSettings := &ms.IndexConfig{
|
||
Uid: indexConfig.UID,
|
||
PrimaryKey: indexConfig.PrimaryKey,
|
||
}
|
||
|
||
if c, ok := client.(interface {
|
||
CreateIndex(*ms.IndexConfig) (*ms.TaskInfo, error)
|
||
}); ok {
|
||
task, err := c.CreateIndex(indexSettings)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return task.TaskUID, nil
|
||
}
|
||
return 0, fmt.Errorf("client does not support CreateIndex")
|
||
}
|
||
|
||
// DeleteIndex 删除索引
|
||
func (m *meilisearchDB) DeleteIndex(ctx context.Context, indexName string) (err error) {
|
||
client, err := m.getClient()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
if c, ok := client.(interface{ DeleteIndex(string) error }); ok {
|
||
return c.DeleteIndex(indexName)
|
||
}
|
||
return fmt.Errorf("client does not support DeleteIndex")
|
||
}
|
||
|
||
// GetIndex 获取索引信息
|
||
func (m *meilisearchDB) GetIndex(ctx context.Context, indexName string) (interface{}, error) {
|
||
client, err := m.getClient()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
if c, ok := client.(interface {
|
||
GetIndex(string) (interface{}, error)
|
||
}); ok {
|
||
return c.GetIndex(indexName)
|
||
}
|
||
return nil, fmt.Errorf("client does not support GetIndex")
|
||
}
|
||
|
||
// GetIndexes 获取所有索引
|
||
func (m *meilisearchDB) GetIndexes(ctx context.Context) (interface{}, error) {
|
||
client, err := m.getClient()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
if c, ok := client.(interface {
|
||
GetIndexes(interface{}) (interface{}, error)
|
||
}); ok {
|
||
return c.GetIndexes(nil)
|
||
}
|
||
return nil, fmt.Errorf("client does not support GetIndexes")
|
||
}
|
||
|
||
// UpdateSettings 更新索引设置
|
||
func (m *meilisearchDB) UpdateSettings(ctx context.Context, indexName string, settings *ms.Settings) (taskUID int64, err error) {
|
||
c, err := m.getClient()
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
idx := indexInterface(indexName, c)
|
||
var task *ms.TaskInfo
|
||
if i, ok := idx.(interface {
|
||
UpdateSettings(*ms.Settings) (*ms.TaskInfo, error)
|
||
}); ok {
|
||
task, err = i.UpdateSettings(settings)
|
||
} else {
|
||
return 0, fmt.Errorf("index does not support UpdateSettings method")
|
||
}
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
return task.TaskUID, nil
|
||
}
|
||
|
||
// GetSettings 获取索引设置
|
||
func (m *meilisearchDB) GetSettings(ctx context.Context, indexName string) (*ms.Settings, error) {
|
||
c, err := m.getClient()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
idx := indexInterface(indexName, c)
|
||
var settings *ms.Settings
|
||
if i, ok := idx.(interface{ GetSettings() (*ms.Settings, error) }); ok {
|
||
settings, err = i.GetSettings()
|
||
} else {
|
||
return nil, fmt.Errorf("index does not support GetSettings method")
|
||
}
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return settings, nil
|
||
}
|
||
|
||
// GetClient 获取原始客户端（用于高级操作）
|
||
func (m *meilisearchDB) GetClient() (interface{ Index(string) interface{} }, error) {
|
||
return m.getClient()
|
||
}
|
||
|
||
// BuildUpdateData 构建更新数据
|
||
func BuildUpdateData(ctx context.Context, req interface{}) (map[string]interface{}, error) {
|
||
return gconv.Map(req), nil
|
||
}
|