database

type FilterFunction func(raw map[string]any, filter QueryFilter) bool

type IDataCache interface {

	// Ping Test connectivity for retries number of time with time interval (in seconds) between retries
	Ping(retries uint, intervalInSeconds uint) error

	// Close cache and free resources
	Close()

	// Get the value of a key
	Get(factory EntityFactory, key string) (result Entity, err error)

	// Set value of key with expiration
	Set(key string, entity Entity) (err error)

	// Del Delete keys
	Del(keys ...string) (err error)

	// MGet Get the value of all the given keys
	MGet(factory EntityFactory, keys ...string) (results []Entity, err error)

	// SetNX Set the value of a key only if the key does not exist
	SetNX(key string, entity Entity, expiration time.Duration) (result bool, err error)

	// SetWithExp Set object value to a key with expiration
	SetWithExp(key string, entity Entity, expiration time.Duration) (err error)

	// Rename a key
	Rename(key string, newKey string) (err error)

	// Scan keys from the provided cursor
	Scan(from uint64, match string, count int64) (keys []string, cursor uint64, err error)

	// Exists Check if key exists
	Exists(key string) (result bool, err error)

	// HGet Get the value of a hash field
	HGet(factory EntityFactory, key, field string) (result Entity, err error)

	// HKeys Get all the fields in a hash
	HKeys(key string) (fields []string, err error)

	// HGetAll Get all the fields and values in a hash
	HGetAll(factory EntityFactory, key string) (result map[string]Entity, err error)

	// HSet Set the value of a hash field
	HSet(key, field string, entity Entity) (err error)

	// HDel Delete one or more hash fields
	HDel(key string, fields ...string) (err error)

	// HSetNX Set the value of a key only if the key does not exist
	HSetNX(key, field string, entity Entity) (result bool, err error)

	// HExists Check if key exists
	HExists(key, field string) (result bool, err error)

	// RPush Append one or multiple values to a list
	RPush(key string, value ...Entity) (err error)

	// LPush Prepend one or multiple values to a list
	LPush(key string, value ...Entity) (err error)

	// RPop Remove and get the last element in a list
	RPop(factory EntityFactory, key string) (entity Entity, err error)

	// LPop Remove and get the first element in a list
	LPop(factory EntityFactory, key string) (entity Entity, err error)

	// BRPop Remove and get the last element in a list or block until one is available
	BRPop(factory EntityFactory, timeout time.Duration, keys ...string) (key string, entity Entity, err error)

	// BLPop Remove and get the first element in a list or block until one is available
	BLPop(factory EntityFactory, timeout time.Duration, keys ...string) (key string, entity Entity, err error)

	// LRange Get a range of elements from list
	LRange(factory EntityFactory, key string, start, stop int64) (result []Entity, err error)

	// LLen Get the length of a list
	LLen(key string) (result int64)
}

type IDatabase interface {

	// Ping Test database connectivity for retries number of time with time interval (in seconds) between retries
	Ping(retries uint, intervalInSeconds uint) error

	// Get a single entity by ID
	Get(factory EntityFactory, entityID string, keys ...string) (result Entity, err error)

	// List Get multiple entities by IDs
	List(factory EntityFactory, entityIDs []string, keys ...string) (list []Entity, err error)

	// Exists Check if entity exists by ID
	Exists(factory EntityFactory, entityID string, keys ...string) (result bool, err error)

	// Insert new entity
	Insert(entity Entity) (added Entity, err error)

	// Update existing entity
	Update(entity Entity) (updated Entity, err error)

	// Upsert Update entity or create it if it does not exist
	Upsert(entity Entity) (updated Entity, err error)

	// Delete entity by id and shard (key)
	Delete(factory EntityFactory, entityID string, keys ...string) (err error)

	// BulkInsert Insert multiple entities
	BulkInsert(entities []Entity) (affected int64, err error)

	// BulkUpdate Update multiple entities
	BulkUpdate(entities []Entity) (affected int64, err error)

	// BulkUpsert Update or insert multiple entities
	BulkUpsert(entities []Entity) (affected int64, err error)

	// BulkDelete Delete multiple entities by IDs
	BulkDelete(factory EntityFactory, entityIDs []string, keys ...string) (affected int64, err error)

	// SetField Update single field of the document in a single transaction (eliminates the need to fetch - change - update)
	SetField(factory EntityFactory, entityID string, field string, value any, keys ...string) (err error)

	// SetFields Update some fields of the document in a single transaction (eliminates the need to fetch - change - update)
	SetFields(factory EntityFactory, entityID string, fields map[string]any, keys ...string) (err error)

	// Query Utility struct method to build a query
	Query(factory EntityFactory) IQuery

	// Close DB and free resources
	Close()

	// ExecuteDDL Execute DDL - create table and indexes
	ExecuteDDL(ddl map[string][]string) (err error)

	// ExecuteSQL Execute SQL - execute SQL command
	ExecuteSQL(sql string, args ...any) (affected int64, err error)

	// DropTable Drop table and indexes
	DropTable(table string) (err error)

	// PurgeTable Fast delete table content (truncate)
	PurgeTable(table string) (err error)
}

type IDatastore interface {

	// Test database connectivity for retries number of time with time interval (in seconds) between retries
	Ping(retries uint, intervalInSeconds uint) error

	// Get single entity by ID
	Get(factory EntityFactory, entityID string, keys ...string) (result Entity, err error)

	// Get multiple entities by IDs
	List(factory EntityFactory, entityIDs []string, keys ...string) (list []Entity, err error)

	// Check if entity exists by ID
	Exists(factory EntityFactory, entityID string, keys ...string) (result bool, err error)

	// Insert new entity
	Insert(entity Entity) (added Entity, err error)

	// Update existing entity
	Update(entity Entity) (updated Entity, err error)

	// Update entity or create it if it does not exist
	Upsert(entity Entity) (updated Entity, err error)

	// Delete entity by id and shard (key)
	Delete(factory EntityFactory, entityID string, keys ...string) (err error)

	// Insert multiple entities
	BulkInsert(entities []Entity) (affected int64, err error)

	// Update multiple entities
	BulkUpdate(entities []Entity) (affected int64, err error)

	// Update or insert multiple entities
	BulkUpsert(entities []Entity) (affected int64, err error)

	// Delete multiple entities by IDs
	BulkDelete(factory EntityFactory, entityIDs []string, keys ...string) (affected int64, err error)

	// Update single field of the document in a single transaction (eliminates the need to fetch - change - update)
	SetField(factory EntityFactory, entityID string, field string, value any, keys ...string) (err error)

	// Update some fields of the document in a single transaction (eliminates the need to fetch - change - update)
	SetFields(factory EntityFactory, entityID string, fields map[string]any, keys ...string) (err error)

	// Utility struct method to build a query
	Query(factory EntityFactory) IQuery

	// Close DB and free resources
	Close()

	// Index Actions ---------------------------------------------------------------------------------------------------
	// Test if index exists
	IndexExists(indexName string) (exists bool)

	// Create index by name (without mapping)
	CreateIndex(indexName string) (name string, err error)

	// Create index of entity and add entity field mapping
	CreateEntityIndex(factory EntityFactory, key string) (name string, err error)

	// Drop index
	DropIndex(indexName string) (ack bool, err error)
}

type IQuery interface {

	// Add callback to apply on each result entity in the query
	Apply(cb func(in Entity) Entity) IQuery

	// Add single field filter
	Filter(filter QueryFilter) IQuery

	// Add list of filters, all of them should be satisfied (AND)
	MatchAll(filters ...QueryFilter) IQuery

	// Add list of filters, any of them should be satisfied (OR)
	MatchAny(filters ...QueryFilter) IQuery

	// Add sort order by field,  expects sort parameter in the following form: field_name (Ascending) or field_name- (Descending)
	Sort(sort string) IQuery

	// Set page number (for pagination)
	Page(page int) IQuery

	// Set page size limit (for pagination)
	Limit(page int) IQuery

	// Execute a query to get list of entities by IDs (the criteria is ignored)
	List(entityIDs []string, keys ...string) (out []Entity, err error)

	// Execute the query based on the criteria, order and pagination
	Find(keys ...string) (out []Entity, total int64, err error)

	// Execute the query based on the criteria, order and pagination and return only the count of matching rows
	Count(keys ...string) (total int64, err error)

	// Execute query based on the where criteria to get a single (the first) result
	FindSingle(keys ...string) (entity Entity, err error)

	// Execute query based on the criteria, order and pagination and return the results as a map of id->Entity
	GetMap(keys ...string) (out map[string]Entity, err error)

	// Execute query based on the where criteria, order and pagination and return the results as a list of Ids
	GetIds(keys ...string) (out []string, err error)

	// Delete the entities satisfying the criteria
	Delete(keys ...string) (total int64, err error)

	// Update single field of all the documents meeting the criteria in a single transaction
	SetField(field string, value any, keys ...string) (total int64, err error)

	// Update multiple fields of all the documents meeting the criteria in a single transaction
	SetFields(fields map[string]any, keys ...string) (total int64, err error)

	// Get the string representation of the query
	ToString() string
}

type ITable interface {

	// Get single entity by ID
	Get(entityID string) (entity Entity, err error)

	// Check if entity exists by ID
	Exists(entityID string) (result bool, err error)

	// Insert entity
	Insert(entity Entity) (added Entity, err error)

	// Update entity
	Update(entity Entity) (added Entity, err error)

	// Update entity or insert if not found
	Upsert(entity Entity) (added Entity, err error)

	// Delete entity
	Delete(entityID string) (err error)

	// Get access to the underlying data structure
	Table() (result map[string]Entity)
}

type InMemoryDataCache struct {
	// contains filtered or unexported fields
}

type InMemoryDatabase struct {
	// contains filtered or unexported fields
}

type InMemoryDatastore struct {
	// contains filtered or unexported fields
}

type InMemoryTable struct {
	// contains filtered or unexported fields
}

type QueryFilter interface {

	// Equal
	Eq(value any) QueryFilter

	// Not equal
	Neq(value any) QueryFilter

	// Like
	Like(value string) QueryFilter

	// Greater
	Gt(value any) QueryFilter

	// Greater or equal
	Gte(value any) QueryFilter

	// Less than
	Lt(value any) QueryFilter

	// Less or equal
	Lte(value any) QueryFilter

	// In
	In(values ...any) QueryFilter

	// Not In
	NotIn(values ...any) QueryFilter

	// Between
	Between(value1, value2 any) QueryFilter

	// Include this filter only if condition is true
	If(value bool) QueryFilter

	// Include this filter only if condition is true
	IsActive() bool

	// Get the field name
	GetField() string

	// Get the criteria operator
	GetOperator() QueryOperator

	// Get the criteria values
	GetValues() []any

	// Get string representation of the value
	GetStringValue(index int) string
}

type QueryOperator string