Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

module

package

Go to main page

Versions in this module

v1

v1.0.4

Nov 30, 2023

v1.0.3

Oct 24, 2023

v1.0.2

Sep 21, 2023

v1.0.1

Sep 15, 2023

v1.0.0

Sep 15, 2023

Changes in this version

+ const Feature_Store_Item

+ const Feature_Store_User

+ const Feature_Type_RT_Cnt

+ const Feature_Type_Sequence

+ const ITEM

+ const REDIS_DATA_TYPE_HASH

+ const REDIS_DATA_TYPE_STRING

+ const REDIS_FIELD_TYPE_CSV

+ const REDIS_FIELD_TYPE_JSON

+ const SQL_Delete_History

+ const SQL_Filter_History

+ const SQL_Insert_History

+ const SQL_Item_Filter

+ const SQL_Topic_Item_Filter

+ const SQL_User_Filter

+ const SQL_User_Topic_Filter

+ const USER

+ var VectoryEmptyError = errors.New("vector empty")

+ func FetchPartition(hologresName, table, field string) string

+ func RegisterGenerateItemDataFunc(name string, f GenerateItemDataFunc)

+ type BoostScoreByWeightByWeightHologresDao struct

+ ItemFieldName string

+ WeightFieldName string

+ func NewBoostScoreByWeightHologresDao(config recconf.SortConfig) *BoostScoreByWeightByWeightHologresDao

+ func (s *BoostScoreByWeightByWeightHologresDao) GetItems() map[string]float64

+ func (s *BoostScoreByWeightByWeightHologresDao) Sort(items []*Item) []*Item

+ type BoostScoreByWeightDao interface

+ Sort func(items []*Item) (resultItems []*Item)

+ func NewBoostScoreByWeightDao(config recconf.SortConfig) BoostScoreByWeightDao

+ type ColdStartRecallDao interface

+ ListItemsByUser func(user *User, context *context.RecommendContext) []*Item

+ func NewColdStartRecallDao(config recconf.RecallConfig) ColdStartRecallDao

+ type ColdStartRecallHologresDao struct

+ func NewColdStartRecallHologresDao(config recconf.RecallConfig) *ColdStartRecallHologresDao

+ func (d *ColdStartRecallHologresDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type ContainsFilterOp struct

+ Domain string

+ Name string

+ Type string

+ Value interface{}

+ func NewContainsFilterOp(config recconf.FilterParamConfig) *ContainsFilterOp

+ func (p *ContainsFilterOp) ContainsEvaluate(properties map[string]interface{}, userProperties map[string]interface{}, ...) (bool, error)

+ func (p *ContainsFilterOp) Evaluate(properties map[string]interface{}) (bool, error)

+ func (p *ContainsFilterOp) OpDomain() string

+ type DiversityDao interface

+ GetDistinctFields func() []string

+ GetDistinctValue func(items []*Item, ctx *context.RecommendContext) error

+ func NewDiversityDao(config recconf.FilterConfig) DiversityDao

+ type DiversityHologresDao struct

+ func NewDiversityHologresDao(config recconf.FilterConfig) *DiversityHologresDao

+ func (d *DiversityHologresDao) GetDistinctFields() []string

+ func (d *DiversityHologresDao) GetDistinctValue(items []*Item, ctx *pctx.RecommendContext) error

+ type EmptyFeatureDao struct

+ func NewEmptyFeatureDao(config recconf.FeatureDaoConfig) *EmptyFeatureDao

+ func (d *EmptyFeatureDao) FeatureFetch(user *User, items []*Item, context *context.RecommendContext)

+ type EqualFilterOp struct

+ Domain string

+ Name string

+ Type string

+ Value interface{}

+ func NewEqualFilterOp(config recconf.FilterParamConfig) *EqualFilterOp

+ func (p *EqualFilterOp) Evaluate(properties map[string]interface{}) (bool, error)

+ func (p *EqualFilterOp) OpDomain() string

+ type FeatureBaseDao struct

+ func NewFeatureBaseDao(config *recconf.FeatureDaoConfig) *FeatureBaseDao

+ type FeatureBeDao struct

+ func NewFeatureBeDao(config recconf.FeatureDaoConfig) *FeatureBeDao

+ func (d *FeatureBeDao) FeatureFetch(user *User, items []*Item, context *context.RecommendContext)

+ type FeatureClickHouseDao struct

+ func NewFeatureClickHouseDao(config recconf.FeatureDaoConfig) *FeatureClickHouseDao

+ func (d *FeatureClickHouseDao) FeatureFetch(user *User, items []*Item, context *context.RecommendContext)

+ type FeatureDao interface

+ FeatureFetch func(user *User, items []*Item, context *context.RecommendContext)

+ func NewFeatureDao(config recconf.FeatureDaoConfig) FeatureDao

+ type FeatureFeatureStoreDao struct

+ func NewFeatureFeatureStoreDao(config recconf.FeatureDaoConfig) *FeatureFeatureStoreDao

+ func (d *FeatureFeatureStoreDao) FeatureFetch(user *User, items []*Item, context *context.RecommendContext)

+ type FeatureHBaseThriftDao struct

+ func NewFeatureHBaseThriftDao(config recconf.FeatureDaoConfig) *FeatureHBaseThriftDao

+ func (d *FeatureHBaseThriftDao) FeatureFetch(user *User, items []*Item, context *context.RecommendContext)

+ type FeatureHologresDao struct

+ func NewFeatureHologresDao(config recconf.FeatureDaoConfig) *FeatureHologresDao

+ func (d *FeatureHologresDao) FeatureFetch(user *User, items []*Item, context *context.RecommendContext)

+ type FeatureLindormDao struct

+ func NewFeatureLindormDao(config recconf.FeatureDaoConfig) *FeatureLindormDao

+ func (d *FeatureLindormDao) FeatureFetch(user *User, items []*Item, context *context.RecommendContext)

+ type FeatureMysqlDao struct

+ func NewFeatureMysqlDao(config recconf.FeatureDaoConfig) *FeatureMysqlDao

+ func (d *FeatureMysqlDao) FeatureFetch(user *User, items []*Item, context *context.RecommendContext)

+ type FeatureRedisDao struct

+ func NewFeatureRedisDao(config recconf.FeatureDaoConfig) *FeatureRedisDao

+ func (d *FeatureRedisDao) FeatureFetch(user *User, items []*Item, context *context.RecommendContext)

+ type FeatureTablestoreDao struct

+ func NewFeatureTablestoreDao(config recconf.FeatureDaoConfig) *FeatureTablestoreDao

+ func (d *FeatureTablestoreDao) FeatureFetch(user *User, items []*Item, context *context.RecommendContext)

+ type FilterOp interface

+ Evaluate func(map[string]interface{}) (bool, error)

+ OpDomain func() string

+ type FilterParam struct

+ func NewFilterParamWithConfig(configs []recconf.FilterParamConfig) *FilterParam

+ func (p *FilterParam) Evaluate(properties map[string]interface{}) (bool, error)

+ func (p *FilterParam) EvaluateByDomain(userProperties, itemProperties map[string]interface{}) (bool, error)

+ type GenerateItemDataFunc func(uid UID, item *Item) string

+ type GreaterFilterOp struct

+ Domain string

+ Name string

+ Type string

+ Value interface{}

+ func NewGreaterFilterOp(config recconf.FilterParamConfig) *GreaterFilterOp

+ func (p *GreaterFilterOp) Evaluate(properties map[string]interface{}) (bool, error)

+ func (p *GreaterFilterOp) OpDomain() string

+ type GreaterThanFilterOp struct

+ Domain string

+ Name string

+ Type string

+ Value interface{}

+ func NewGreaterThanFilterOp(config recconf.FilterParamConfig) *GreaterThanFilterOp

+ func (p *GreaterThanFilterOp) Evaluate(properties map[string]interface{}) (bool, error)

+ func (p *GreaterThanFilterOp) OpDomain() string

+ type InFilterOp struct

+ Domain string

+ Name string

+ Type string

+ func NewInFilterOp(config recconf.FilterParamConfig) *InFilterOp

+ func (p *InFilterOp) Evaluate(properties map[string]interface{}) (bool, error)

+ func (p *InFilterOp) OpDomain() string

+ type Item struct

+ Embedding []float64

+ Id ItemId

+ ItemType string

+ Name string

+ Properties map[string]interface{}

+ RetrieveId string

+ Score float64

+ func NewItem(id string) *Item

+ func NewItemWithProperty(id string, properties map[string]interface{}) *Item

+ func (t *Item) AddAlgoScore(name string, score float64)

+ func (t *Item) AddAlgoScores(scores map[string]float64)

+ func (t *Item) AddProperties(properties map[string]interface{})

+ func (t *Item) AddProperty(key string, value interface{})

+ func (t *Item) AddRecallNameFeature()

+ func (t *Item) CloneAlgoScores() map[string]float64

+ func (t *Item) DeepClone() *Item

+ func (t *Item) DeleteProperties(features []string)

+ func (t *Item) DeleteProperty(key string)

+ func (t *Item) FloatExprData(name string) (float64, error)

+ func (t *Item) FloatProperty(key string) (float64, error)

+ func (t *Item) GetAlgoScore(key string) float64

+ func (t *Item) GetAlgoScores() map[string]float64

+ func (t *Item) GetCloneFeatures() map[string]interface{}

+ func (t *Item) GetFeatures() map[string]interface{}

+ func (t *Item) GetProperties() map[string]interface{}

+ func (t *Item) GetProperty(key string) interface{}

+ func (t *Item) GetRecallName() string

+ func (t *Item) IncrAlgoScore(name string, score float64)

+ func (t *Item) IntProperty(key string) (int, error)

+ func (t *Item) StringProperty(key string) string

+ type ItemCollaborativeDao interface

+ ListItemsByItem func(item *User, context *context.RecommendContext) []*Item

+ func NewItemCollaborativeDao(config recconf.RecallConfig) ItemCollaborativeDao

+ type ItemCollaborativeHologresDao struct

+ func NewItemCollaborativeHologresDao(config recconf.RecallConfig) *ItemCollaborativeHologresDao

+ func (d *ItemCollaborativeHologresDao) ListItemsByItem(user *User, context *context.RecommendContext) (ret []*Item)

+ type ItemCustomFilterDao interface

+ GetFilterItems func() (ret map[ItemId]bool)

+ func NewItemCustomFilterDao(config recconf.FilterConfig) ItemCustomFilterDao

+ type ItemCustomFilterHoloDao struct

+ func NewItemCustomFilterHoloDao(config recconf.FilterConfig) *ItemCustomFilterHoloDao

+ func (i *ItemCustomFilterHoloDao) GetFilterItems() map[ItemId]bool

+ type ItemCustomFilterTableStoreDao struct

+ func NewItemCustomFilterTableStoreDao(config recconf.FilterConfig) *ItemCustomFilterTableStoreDao

+ func (d *ItemCustomFilterTableStoreDao) GetFilterItems() (ret map[ItemId]bool)

+ type ItemId string

+ type ItemScoreSlice []*Item

+ func (us ItemScoreSlice) Len() int

+ func (us ItemScoreSlice) Less(i, j int) bool

+ func (us ItemScoreSlice) Swap(i, j int)

+ type ItemStateFilterDao interface

+ Filter func(user *User, ids []*Item) (ret []*Item)

+ func NewItemStateFilterDao(config recconf.FilterConfig) ItemStateFilterDao

+ type ItemStateFilterHBaseThriftDao struct

+ func NewItemStateFilterHBaseThriftDao(config recconf.FilterConfig) *ItemStateFilterHBaseThriftDao

+ func (d *ItemStateFilterHBaseThriftDao) Filter(user *User, items []*Item) (ret []*Item)

+ type ItemStateFilterHologresDao struct

+ func NewItemStateFilterHologresDao(config recconf.FilterConfig) *ItemStateFilterHologresDao

+ func (d *ItemStateFilterHologresDao) Filter(user *User, items []*Item) (ret []*Item)

+ type ItemStateFilterTablestoreDao struct

+ func NewItemStateFilterTablestoreDao(config recconf.FilterConfig) *ItemStateFilterTablestoreDao

+ func (d *ItemStateFilterTablestoreDao) Filter(user *User, items []*Item) (ret []*Item)

+ type LessFilterOp struct

+ Domain string

+ Name string

+ Type string

+ Value interface{}

+ func NewLessFilterOp(config recconf.FilterParamConfig) *LessFilterOp

+ func (p *LessFilterOp) Evaluate(properties map[string]interface{}) (bool, error)

+ func (p *LessFilterOp) OpDomain() string

+ type LessThanFilterOp struct

+ Domain string

+ Name string

+ Type string

+ Value interface{}

+ func NewLessThanFilterOp(config recconf.FilterParamConfig) *LessThanFilterOp

+ func (p *LessThanFilterOp) Evaluate(properties map[string]interface{}) (bool, error)

+ func (p *LessThanFilterOp) OpDomain() string

+ type NotContainsFilterOp struct

+ Domain string

+ Name string

+ Type string

+ Value interface{}

+ func NewNotContainsFilterOp(config recconf.FilterParamConfig) *NotContainsFilterOp

+ func (p *NotContainsFilterOp) ContainsEvaluate(properties map[string]interface{}, userProperties map[string]interface{}, ...) (bool, error)

+ func (p *NotContainsFilterOp) Evaluate(properties map[string]interface{}) (bool, error)

+ func (p *NotContainsFilterOp) OpDomain() string

+ type NotEqualFilterOp struct

+ Domain string

+ Name string

+ Type string

+ Value interface{}

+ func NewNotEqualFilterOp(config recconf.FilterParamConfig) *NotEqualFilterOp

+ func (p *NotEqualFilterOp) Evaluate(properties map[string]interface{}) (bool, error)

+ func (p *NotEqualFilterOp) OpDomain() string

+ type NotInFilterOp struct

+ Domain string

+ Name string

+ Type string

+ func NewNotInFilterOp(config recconf.FilterParamConfig) *NotInFilterOp

+ func (p *NotInFilterOp) Evaluate(properties map[string]interface{}) (bool, error)

+ func (p *NotInFilterOp) NotInEvaluate(properties map[string]interface{}, userProperties map[string]interface{}, ...) (bool, error)

+ func (p *NotInFilterOp) OpDomain() string

+ type RTCntField struct

+ type RealTimeUser2ItemDao interface

+ GetTriggerInfos func(user *User, context *context.RecommendContext) []*TriggerInfo

+ GetTriggers func(user *User, context *context.RecommendContext) map[string]float64

+ ListItemsByUser func(user *User, context *context.RecommendContext) []*Item

+ func NewRealTimeUser2ItemDao(config recconf.RecallConfig) RealTimeUser2ItemDao

+ type RealtimeUser2ItemBaseDao struct

+ func NewRealtimeUser2ItemBaseDao(config *recconf.RecallConfig) *RealtimeUser2ItemBaseDao

+ func (d *RealtimeUser2ItemBaseDao) DiversityTriggers(triggers []*TriggerInfo) []*TriggerInfo

+ type RealtimeUser2ItemBeDao struct

+ func NewRealtimeUser2ItemBeDao(config recconf.RecallConfig) *RealtimeUser2ItemBeDao

+ func (d *RealtimeUser2ItemBeDao) GetTriggerInfos(user *User, context *context.RecommendContext) (triggerInfos []*TriggerInfo)

+ func (d *RealtimeUser2ItemBeDao) GetTriggers(user *User, context *context.RecommendContext) (itemTriggers map[string]float64)

+ func (d *RealtimeUser2ItemBeDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type RealtimeUser2ItemHologresDao struct

+ func NewRealtimeUser2ItemHologresDao(config recconf.RecallConfig) *RealtimeUser2ItemHologresDao

+ func (d *RealtimeUser2ItemHologresDao) GetTriggerInfos(user *User, context *context.RecommendContext) (triggerInfos []*TriggerInfo)

+ func (d *RealtimeUser2ItemHologresDao) GetTriggers(user *User, context *context.RecommendContext) (itemTriggers map[string]float64)

+ func (d *RealtimeUser2ItemHologresDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type Trigger struct

+ func NewTrigger(triggers []recconf.TriggerConfig) *Trigger

+ func (t *Trigger) GetValue(features map[string]interface{}) string

+ type TriggerDiversityRule struct

+ DimensionItemMap map[string]string

+ DimensionValueSize map[string]int

+ DiversityRuleConfig recconf.TriggerDiversityRuleConfig

+ func NewTriggerDiversityRule(config recconf.TriggerDiversityRuleConfig) *TriggerDiversityRule

+ func (r *TriggerDiversityRule) AddDimensionValue(trigger *TriggerInfo, propertyFieldMap map[string]int)

+ func (r *TriggerDiversityRule) GetDimensionValue(trigger *TriggerInfo, propertyFieldMap map[string]int) string

+ func (r *TriggerDiversityRule) Match(trigger *TriggerInfo, propertyFieldMap map[string]int, ...) bool

+ type TriggerInfo struct

+ ItemId string

+ Weight float64

+ func (t *TriggerInfo) StringProperty(dimension string, propertyFieldMap map[string]int) string

+ type TriggerInfoSlice []*TriggerInfo

+ func (us TriggerInfoSlice) Len() int

+ func (us TriggerInfoSlice) Less(i, j int) bool

+ func (us TriggerInfoSlice) Swap(i, j int)

+ type TriggerItem struct

+ Boundaries []int

+ DefaultValue string

+ Key string

+ func (tr *TriggerItem) GetValue(feature interface{}) string

+ type UID string

+ type User struct

+ Id UID

+ Properties map[string]interface{}

+ func NewUser(id string) *User

+ func NewUserWithContext(id UID, context *context.RecommendContext) *User

+ func (u *User) AddCacheFeatures(key string, features map[string]any)

+ func (u *User) AddProperties(properties map[string]interface{})

+ func (u *User) AddProperty(key string, value interface{})

+ func (u *User) Clone() *User

+ func (u *User) DeleteProperties(features []string)

+ func (u *User) DeleteProperty(key string)

+ func (u *User) DescFeatureAsyncLoadCount(count int32)

+ func (u *User) FeatureAsyncLoadCh() <-chan struct{}

+ func (u *User) FeatureAsyncLoadCount() int32

+ func (u *User) FloatProperty(key string) (float64, error)

+ func (u *User) GetCacheFeatures(key string) (result map[string]interface{})

+ func (u *User) GetCacheFeaturesNames() (ret []string)

+ func (u *User) GetEmbeddingFeature() (features map[string]interface{})

+ func (u *User) GetProperty(key string) interface{}

+ func (u *User) IncrementFeatureAsyncLoadCount(count int32)

+ func (u *User) IntProperty(key string) (int, error)

+ func (u *User) LoadCacheFeatures(key string)

+ func (u *User) MakeUserFeatures() (features map[string]interface{})

+ func (u *User) MakeUserFeatures2() (features map[string]interface{})

+ func (u *User) SetProperties(p map[string]interface{})

+ func (u *User) StringProperty(key string) string

+ type User2ItemCustomFilterDao interface

+ Filter func(uid UID, ids []*Item) (ret []*Item)

+ func NewUser2ItemCustomFilterDao(config recconf.FilterConfig) User2ItemCustomFilterDao

+ type User2ItemCustomFilterTableStoreDao struct

+ func NewUser2ItemCustomFilterTableStoreDao(config recconf.FilterConfig) *User2ItemCustomFilterTableStoreDao

+ func (d *User2ItemCustomFilterTableStoreDao) Filter(uid UID, items []*Item) (ret []*Item)

+ type User2ItemDao interface

+ ListItemsByUser func(user *User, context *context.RecommendContext) []*Item

+ func NewUser2ItemDao(config recconf.RecallConfig) User2ItemDao

+ type User2ItemExposureBeDao struct

+ func NewUser2ItemExposureBeDao(config recconf.FilterConfig) *User2ItemExposureBeDao

+ func (d *User2ItemExposureBeDao) ClearHistory(user *User, context *context.RecommendContext)

+ func (d *User2ItemExposureBeDao) FilterByHistory(uid UID, items []*Item) (ret []*Item)

+ func (d *User2ItemExposureBeDao) GetExposureItemIds(user *User, context *context.RecommendContext) (ret string)

+ func (d *User2ItemExposureBeDao) LogHistory(user *User, items []*Item, context *context.RecommendContext)

+ type User2ItemExposureDao interface

+ ClearHistory func(user *User, context *context.RecommendContext)

+ FilterByHistory func(uid UID, ids []*Item) (ret []*Item)

+ GetExposureItemIds func(user *User, context *context.RecommendContext) (ret string)

+ LogHistory func(user *User, items []*Item, context *context.RecommendContext)

+ func NewUser2ItemExposureDao(config recconf.FilterConfig) User2ItemExposureDao

+ type User2ItemExposureGraphDao struct

+ func NewUser2ItemExposureGraphDao(config recconf.FilterConfig) *User2ItemExposureGraphDao

+ func (d *User2ItemExposureGraphDao) ClearHistory(user *User, context *context.RecommendContext)

+ func (d *User2ItemExposureGraphDao) FilterByHistory(uid UID, items []*Item) (ret []*Item)

+ func (d *User2ItemExposureGraphDao) GetExposureItemIds(user *User, context *context.RecommendContext) (ret string)

+ func (d *User2ItemExposureGraphDao) LogHistory(user *User, items []*Item, context *context.RecommendContext)

+ type User2ItemExposureHologresDao struct

+ func NewUser2ItemExposureHologresDao(config recconf.FilterConfig) *User2ItemExposureHologresDao

+ func (d *User2ItemExposureHologresDao) ClearHistory(user *User, context *context.RecommendContext)

+ func (d *User2ItemExposureHologresDao) FilterByHistory(uid UID, items []*Item) (ret []*Item)

+ func (d *User2ItemExposureHologresDao) GetExposureItemIds(user *User, context *context.RecommendContext) (ret string)

+ func (d *User2ItemExposureHologresDao) LogHistory(user *User, items []*Item, context *context.RecommendContext)

+ type User2ItemExposureMysqlDao struct

+ func NewUser2ItemExposureMysqlDao(config recconf.FilterConfig) *User2ItemExposureMysqlDao

+ func (d *User2ItemExposureMysqlDao) ClearHistory(user *User, context *context.RecommendContext)

+ func (d *User2ItemExposureMysqlDao) FilterByHistory(uid UID, items []*Item) (ret []*Item)

+ func (d *User2ItemExposureMysqlDao) GetExposureItemIds(user *User, context *context.RecommendContext) (ret string)

+ func (d *User2ItemExposureMysqlDao) LogHistory(user *User, items []*Item, context *context.RecommendContext)

+ type User2ItemExposureRedisDao struct

+ func NewUser2ItemExposureRedisDao(config recconf.FilterConfig) *User2ItemExposureRedisDao

+ func (d *User2ItemExposureRedisDao) ClearHistory(user *User, context *context.RecommendContext)

+ func (d *User2ItemExposureRedisDao) FilterByHistory(uid UID, items []*Item) (ret []*Item)

+ func (d *User2ItemExposureRedisDao) GetExposureItemIds(user *User, context *context.RecommendContext) (ret string)

+ func (d *User2ItemExposureRedisDao) LogHistory(user *User, items []*Item, context *context.RecommendContext)

+ type User2ItemExposureTableStoreDao struct

+ func NewUser2ItemExposureTableStoreDao(config recconf.FilterConfig) *User2ItemExposureTableStoreDao

+ func (d *User2ItemExposureTableStoreDao) ClearHistory(user *User, context *context.RecommendContext)

+ func (d *User2ItemExposureTableStoreDao) FilterByHistory(uid UID, items []*Item) (ret []*Item)

+ func (d *User2ItemExposureTableStoreDao) GetExposureItemIds(user *User, context *context.RecommendContext) (ret string)

+ func (d *User2ItemExposureTableStoreDao) LogHistory(user *User, items []*Item, context *context.RecommendContext)

+ type User2ItemHologresDao struct

+ func NewUser2ItemHologresDao(config recconf.RecallConfig) *User2ItemHologresDao

+ func (d *User2ItemHologresDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserCollaborativeDao interface

+ GetTriggerInfos func(user *User, context *context.RecommendContext) (triggerInfos []*TriggerInfo)

+ GetTriggers func(user *User, context *context.RecommendContext) (itemTriggers map[string]float64)

+ ListItemsByUser func(user *User, context *context.RecommendContext) []*Item

+ func NewUserCollaborativeDao(config recconf.RecallConfig) UserCollaborativeDao

+ type UserCollaborativeHologresDao struct

+ func NewUserCollaborativeHologresDao(config recconf.RecallConfig) *UserCollaborativeHologresDao

+ func (d *UserCollaborativeHologresDao) GetTriggerInfos(user *User, context *context.RecommendContext) (triggerInfos []*TriggerInfo)

+ func (d *UserCollaborativeHologresDao) GetTriggers(user *User, context *context.RecommendContext) (itemTriggers map[string]float64)

+ func (d *UserCollaborativeHologresDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserCollaborativeMysqlDao struct

+ func NewUserCollaborativeMysqlDao(config recconf.RecallConfig) *UserCollaborativeMysqlDao

+ func (d *UserCollaborativeMysqlDao) GetTriggerInfos(user *User, context *context.RecommendContext) (triggerInfos []*TriggerInfo)

+ func (d *UserCollaborativeMysqlDao) GetTriggers(user *User, context *context.RecommendContext) (itemTriggers map[string]float64)

+ func (d *UserCollaborativeMysqlDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserCollaborativeRedisDao struct

+ func NewUserCollaborativeRedisDao(config recconf.RecallConfig) *UserCollaborativeRedisDao

+ func (d *UserCollaborativeRedisDao) GetTriggerInfos(user *User, context *context.RecommendContext) (triggerInfos []*TriggerInfo)

+ func (d *UserCollaborativeRedisDao) GetTriggers(user *User, context *context.RecommendContext) (itemTriggers map[string]float64)

+ func (d *UserCollaborativeRedisDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserCollaborativeTableStoreDao struct

+ func NewUserCollaborativeTableStoreDao(config recconf.RecallConfig) *UserCollaborativeTableStoreDao

+ func (d *UserCollaborativeTableStoreDao) GetTriggerInfos(user *User, context *context.RecommendContext) (triggerInfos []*TriggerInfo)

+ func (d *UserCollaborativeTableStoreDao) GetTriggers(user *User, context *context.RecommendContext) (itemTriggers map[string]float64)

+ func (d *UserCollaborativeTableStoreDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserCustomRecallClickHouseDao struct

+ func NewUserCusteomRecallClickHouseDao(config recconf.RecallConfig) *UserCustomRecallClickHouseDao

+ func (d *UserCustomRecallClickHouseDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserCustomRecallDao interface

+ ListItemsByUser func(user *User, context *context.RecommendContext) []*Item

+ func NewUserCustomRecallDao(config recconf.RecallConfig) UserCustomRecallDao

+ type UserCustomRecallHologresDao struct

+ func NewUserCusteomRecallHologresDao(config recconf.RecallConfig) *UserCustomRecallHologresDao

+ func (d *UserCustomRecallHologresDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserCustomRecallMysqlDao struct

+ func NewUserCusteomRecallMysqlDao(config recconf.RecallConfig) *UserCustomRecallMysqlDao

+ func (d *UserCustomRecallMysqlDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserCustomRecallRedisDao struct

+ func NewUserCusteomRecallRedisDao(config recconf.RecallConfig) *UserCustomRecallRedisDao

+ func (d *UserCustomRecallRedisDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserCustomRecallTableStoreDao struct

+ func NewUserCustomRecallTableStoreDao(config recconf.RecallConfig) *UserCustomRecallTableStoreDao

+ func (d *UserCustomRecallTableStoreDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserGlobalHotRecallDao interface

+ ListItemsByUser func(user *User, context *context.RecommendContext) []*Item

+ func NewUserGlobalHotRecallDao(config recconf.RecallConfig) UserGlobalHotRecallDao

+ type UserGlobalHotRecallHologresDao struct

+ func NewUserGlobalHotRecallHologresDao(config recconf.RecallConfig) *UserGlobalHotRecallHologresDao

+ func (d *UserGlobalHotRecallHologresDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserGlobalHotRecallTableStoreDao struct

+ func NewUserGlobalHotRecallTableStoreDao(config recconf.RecallConfig) *UserGlobalHotRecallTableStoreDao

+ func (d *UserGlobalHotRecallTableStoreDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserGroupHotRecallDao interface

+ ListItemsByUser func(user *User, context *context.RecommendContext) []*Item

+ func NewUserGroupHotRecallDao(config recconf.RecallConfig) UserGroupHotRecallDao

+ type UserGroupHotRecallHologresDao struct

+ func NewUserGroupHotRecallHologresDao(config recconf.RecallConfig) *UserGroupHotRecallHologresDao

+ func (d *UserGroupHotRecallHologresDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserTopicDao interface

+ ListItemsByUser func(user *User, context *context.RecommendContext) []*Item

+ func NewUserTopicDao(config recconf.RecallConfig) UserTopicDao

+ type UserTopicMysqlDao struct

+ func NewUserTopicMysqlDao(config recconf.RecallConfig) *UserTopicMysqlDao

+ func (d *UserTopicMysqlDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserTopicTableStoreDao struct

+ func NewUserTopicTableStoreDao(config recconf.RecallConfig) *UserTopicTableStoreDao

+ func (d *UserTopicTableStoreDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type UserVideoCollaborativeMysqlDao struct

+ func NewUserVideoCollaborativeMysqlDao(config recconf.RecallConfig) *UserVideoCollaborativeMysqlDao

+ func (d *UserVideoCollaborativeMysqlDao) GetTriggerInfos(user *User, context *context.RecommendContext) (triggerInfos []*TriggerInfo)

+ func (d *UserVideoCollaborativeMysqlDao) GetTriggers(user *User, context *context.RecommendContext) (itemTriggers map[string]float64)

+ func (d *UserVideoCollaborativeMysqlDao) ListItemsByUser(user *User, context *context.RecommendContext) (ret []*Item)

+ type VectorBeDao struct

+ func NewVectorBeDao(config recconf.RecallConfig) *VectorBeDao

+ func (d *VectorBeDao) VectorString(id string) (string, error)

+ type VectorClickHouseDao struct

+ func NewVectorClickHouseDao(config recconf.RecallConfig) *VectorClickHouseDao

+ func (d *VectorClickHouseDao) VectorString(id string) (string, error)

+ type VectorDao interface

+ VectorString func(id string) (string, error)

+ func NewVectorDao(config recconf.RecallConfig) VectorDao

+ type VectorHBaseDao struct

+ func NewVectorHBaseDao(config recconf.RecallConfig) *VectorHBaseDao

+ func (d *VectorHBaseDao) VectorString(id string) (string, error)

+ type VectorHologresDao struct

+ func NewVectorHologresDao(config recconf.RecallConfig) *VectorHologresDao

+ func (d *VectorHologresDao) VectorString(id string) (string, error)

+ type VectorMysqlDao struct

+ func NewVectorMysqlDao(config recconf.RecallConfig) *VectorMysqlDao

+ func (d *VectorMysqlDao) VectorString(id string) (string, error)

+ type VectorRedisDao struct

+ func NewVectorRedisDao(config recconf.RecallConfig) *VectorRedisDao

+ func (d *VectorRedisDao) VectorString(id string) (string, error)

Other modules containing this package

github.com/alibaba/pairec/v2