indexing

type CommonIndex ¶

type CommonIndex[T comparable] struct {
	// contains filtered or unexported fields
}

CommonIndex is a common implementation of Index. It is thread-safe. It is used by Bucket to provide indexes for its items. It supports the following operations:

• Get(T) ([]int, error)
• Set(T, int) error
• Remove(T, int) error
• Delete(key) error
• Clear()
• Exists(T) bool

func NewCommonIndex[T comparable]() *CommonIndex[T]

func (i *CommonIndex[T]) Clear()

func (i *CommonIndex[T]) Delete(key interface{}) error

func (i *CommonIndex[T]) DeleteID(id int)

func (i *CommonIndex[T]) Exists(key interface{}) bool

func (i *CommonIndex[T]) Get(key interface{}) ([]int, error)

func (i *CommonIndex[T]) Remove(key interface{}, id int) error

func (i *CommonIndex[T]) Set(key interface{}, id int) error

type Index ¶

type Index interface {
	Get(key interface{}) ([]int, error)
	Set(key interface{}, id int) error
	Remove(key interface{}, id int) error
	Delete(key interface{}) error
	DeleteID(id int)
	Clear()
	Exists(key interface{}) bool
}

Index is a generic interface for an index that maps a generic key to one or more IDs It is thread-safe. It is used by Bucket to provide indexes for its items. It supports the following operations:

• Get(T) ([]int, error)
• Set(T, int) error
• Remove(T, int) error
• Delete(key) error
• Clear()
• Exists(T) bool

(where T is the type of the key

and int is the type of the ID
and []int is the type of the IDs
and error is the type of the error
and bool is the type of the boolean

)

type Indexer ¶

type Indexer struct {
	sync.RWMutex
	Indexes map[string]Index
}

Indexer is an index resolver. It is used to resolve a list of IDs that match a list of keys. It uses a map to store indexes by string keys. It is thread-safe. It is used by the Bucket to resolve the IDs of the objects that match a list of keys. It supports both unique and common indexes. It follows the builder pattern. It supports the following operations: - Set(int, map[string]interface{}): sets the IDs of the objects that match the given keys. - Resolve(...key): resolves the IDs of the objects that match the given keys. - Unset(id): removes the given ID from the indexes. - WithIndex(name, index): adds the given index to the indexer. - Clear(): clears the indexer.

func NewIndexer() *Indexer

func (i *Indexer) Clear()

func (i *Indexer) Resolve(indices Indices) []int

func (i *Indexer) Set(id int, indices Indices) error

func (i *Indexer) Unset(id int) error

func (i *Indexer) WithIndex(name string, index Index) *Indexer

type Indices ¶

type Indices map[string]interface{}

Indices is a map of index names to interfaces. It is used to provide indexes for an item when it is added to a bucket.

func (i Indices) String() string

type Set ¶

type Set []int

func (s Set) Contains(id int) bool

func (s Set) Intersect(other Set) Set

func (s Set) Len() int

func (s Set) Less(i, j int) bool

func (s Set) Sort() Set

func (s Set) Swap(i, j int)

func (s Set) Unique() Set

type UniqueIndex ¶

type UniqueIndex[T comparable] struct {
	*CommonIndex[T]
}

UniqueIndex is a unique index. It is thread-safe. It is used by Bucket to provide indexes for its items. It supports the following operations:

• Get(T) ([]int, error)
• Set(T, int) error
• Remove(T, int) error
• Delete(key) error
• Clear()
• Exists(T) bool

func NewUniqueIndex[T comparable]() *UniqueIndex[T]

func (i *UniqueIndex[T]) Set(key interface{}, id int) error