merge
packageAPI reference for the merge
package.
Imports
(3)VectorClock
VectorClock represents the logical time of a value across different regions.
Key: RegionID, Value: Logical Clock Counter.
type VectorClock map[string]uint64
Value
Value wraps a value with a timestamp and vector clock used by merge strategies.
type Value struct
Fields
| Name | Type | Description |
|---|---|---|
| Data | T | |
| Timestamp | time.Time | |
| Vector | VectorClock | |
| Region | string |
Uses
Strategy
Strategy defines how two values should be merged.
type Strategy interface
Methods
MergeFn
MergeFn is a custom merge function provided by the developer.
type MergeFn func(old, new T) (T, error)
LastWriteWins
LastWriteWins is the default merge strategy which keeps the most recent value based on physical timestamp.
It falls back to Vector Clock comparison if available and timestamps are equal.
type LastWriteWins struct
Engine
Engine manages merge functions for specific keys.
type Engine struct
Fields
| Name | Type | Description |
|---|---|---|
| mu | sync.RWMutex | |
| custom | map[string]MergeFn[T] | |
| defaultStrategy | Strategy[T] |
NewEngine
NewEngine creates a new merge engine with LastWriteWins as default strategy.
Returns
func NewEngine[T any]() *Engine[T]
{
return &Engine[T]{custom: make(map[string]MergeFn[T]), defaultStrategy: LastWriteWins[T]{}}
}TestEngineConcurrentAccess
Parameters
func TestEngineConcurrentAccess(t *testing.T)
{
e := NewEngine[int]()
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
for range 100 {
e.Register("key", func(old, new int) (int, error) {
return new, nil
})
}
}()
go func() {
defer wg.Done()
for i := range 100 {
_, err := e.Merge("key", Value[int]{Data: i, Timestamp: time.Now()}, Value[int]{Data: i + 1, Timestamp: time.Now()})
if err != nil {
t.Errorf("unexpected error: %v", err)
}
}
}()
wg.Wait()
}VersionedValue
VersionedValue keeps a history of values with timestamps.
It maintains only the most recent limit entries.
type VersionedValue struct
Fields
| Name | Type | Description |
|---|---|---|
| versions | []Value[T] | |
| limit | int |
NewVersionedValue
NewVersionedValue creates a VersionedValue with the provided limit
and initializes it with the given value.
Parameters
Returns
func NewVersionedValue[T any](v Value[T], limit int) VersionedValue[T]
{
vv := VersionedValue[T]{limit: limit}
vv.versions = append(vv.versions, v)
return vv
}