storage

type CleanupConfig struct {
	// SampleSize is the number of keys to sample per round
	SampleSize int
	// MaxRounds is the maximum number of rounds per cleanup cycle
	MaxRounds int
	// BatchSize is the number of keys to delete in each batch
	BatchSize int
	// ExpiredThreshold continues cleanup if this percentage of sampled keys are expired
	ExpiredThreshold float64
}

type CleanupConfigurableStorage interface {
	Storage

	// Cleanup configuration
	SetCleanupConfig(config CleanupConfig)
	GetCleanupConfig() CleanupConfig
}

type HashValue struct {
	Fields map[string][]byte
}

type KeyInfo struct {
	Key        string
	Type       ValueType
	TTL        time.Duration // -1 for no expiry, -2 for expired/not found
	Size       int64         // Size in bytes
	LastAccess time.Time
}

type ListValue struct {
	Elements [][]byte
}

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

type MatchingStrategy int

type MemoryLimitedStorage interface {
	Storage

	// Memory management
	SetMemoryLimit(bytes int64)
	GetMemoryLimit() int64
	EvictLRU(count int) int64
}

type MemoryOption func(*MemoryStorage)

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

type SetValue struct {
	Members map[string]struct{}
}

type Snapshot interface {
	// Iterate over all key-value pairs
	ForEach(ctx context.Context, fn func(key string, value *Value) error) error

	// Get snapshot metadata
	Timestamp() time.Time
	KeyCount() int64

	// Cleanup
	Close() error
}

type SnapshotStorage interface {
	Storage

	// Create a point-in-time snapshot
	Snapshot() (Snapshot, error)

	// Restore from snapshot
	Restore(snapshot Snapshot) error
}

type Storage interface {
	// String operations
	Get(key string) ([]byte, bool)
	Set(key string, value []byte, expiry *time.Time) error
	Del(keys ...string) int64
	Exists(keys ...string) int64

	// Expiration operations
	Expire(key string, expiry time.Time) bool
	TTL(key string) time.Duration
	PTTL(key string) time.Duration

	// Key operations
	Keys(pattern string) []string
	KeyCount() int64
	FlushAll() error

	// Type operations
	Type(key string) ValueType

	// Memory operations
	MemoryUsage() int64

	// Database operations
	SelectDB(db int) error
	CurrentDB() int

	// Iteration
	Scan(cursor int64, match string, count int64) (int64, []string)

	// Info and stats
	Info() map[string]interface{}
	DatabaseInfo() map[int]map[string]interface{}

	// Shutdown
	Close() error
}

type StorageObserver interface {
	OnKeySet(key string, value []byte)
	OnKeyDeleted(key string)
	OnKeyExpired(key string)
	OnKeyAccessed(key string)
}

type StreamEntry struct {
	ID     string
	Fields map[string][]byte
}

type StreamValue struct {
	Entries []StreamEntry
	LastID  string
}

type StringValue struct {
	Data []byte
}

type Transaction interface {
	// Queue commands
	Set(key string, value []byte, expiry *time.Time) Transaction
	Get(key string) Transaction
	Del(keys ...string) Transaction

	// Execute transaction
	Exec() ([]interface{}, error)
	Discard() error
}

type TransactionalStorage interface {
	Storage

	// Transaction operations
	Multi() Transaction
	Watch(keys ...string) error
	Unwatch() error
}

type Value struct {
	Type    ValueType
	Data    interface{}
	Expiry  *time.Time
	Version int64 // For optimistic locking
}

type ValueType int

type ZSetMember struct {
	Member string
	Score  float64
}

type ZSetValue struct {
	Members map[string]float64
	Scores  []ZSetMember // Sorted by score
}