private ORDictionary <TKey, TValue> DryMerge(ORDictionary <TKey, TValue> other, ORSet <TKey> mergedKeys, IEnumerator <TKey> valueKeysEnumerator)
{
var mergedValues = ImmutableDictionary <TKey, TValue> .Empty.ToBuilder();
while (valueKeysEnumerator.MoveNext())
{
var key = valueKeysEnumerator.Current;
TValue value2;
if (ValueMap.TryGetValue(key, out var value1))
{
if (other.ValueMap.TryGetValue(key, out value2))
{
var merged = value1.Merge(value2);
mergedValues[key] = merged;
}
else
{
mergedValues[key] = value1;
}
}
else
{
if (other.ValueMap.TryGetValue(key, out value2))
{
mergedValues[key] = value2;
}
else
{
throw new IllegalStateException($"Missing value for {key}");
}
}
}
return(new ORDictionary <TKey, TValue>(mergedKeys, mergedValues.ToImmutable()));
}
public void ORDictionary_must_not_have_anomalies_for_remove_with_update_scenario_and_deltas_8()
{
var m1 = ORDictionary.Create(_node1, "a", GSet.Create("A"))
.SetItem(_node1, "b", GSet.Create("B"))
.SetItem(_node2, "b", GSet.Create("B"));
var m2 = ORDictionary.Create(_node2, "c", GSet.Create("C"));
var merged1 = m1.Merge(m2);
var m3 = merged1.ResetDelta().Remove(_node1, "b").Remove(_node2, "b");
var m4 = merged1.ResetDelta()
.SetItem(_node2, "b", GSet.Create("B2"))
.SetItem(_node2, "b", GSet.Create("B3"));
var merged2 = m3.Merge(m4);
merged2.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged2.Entries["b"].Elements.Should().BeEquivalentTo("B3");
merged2.Entries["c"].Elements.Should().BeEquivalentTo("C");
var merged3 = merged1.MergeDelta(m3.Delta).MergeDelta(m4.Delta);
merged3.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged3.Entries["b"].Elements.Should().BeEquivalentTo("B3");
merged3.Entries["c"].Elements.Should().BeEquivalentTo("C");
}
public void ORDictionary_must_work_with_deltas_and_Add_for_GSet_elements_type()
{
var m1 = ORDictionary.Create(_node1, "a", GSet.Create("A"));
var m2 = m1.ResetDelta().AddOrUpdate(_node1, "a", GSet <string> .Empty, x => x.Add("B"));
var m3 = ORDictionary <string, GSet <string> > .Empty.MergeDelta(m1.Delta).MergeDelta(m2.Delta);
m3.Entries["a"].Should().BeEquivalentTo("A", "B");
}
public CommandService()
{
this.dbManager = DataBaseManager.GetInstance();
if (this.dbManager != null)
{
this.mapping = this.dbManager.Mapping;
this.connection = this.dbManager.DataBaseConnection;
}
}
public LWWDictionary <TKey, TValue> MergeDelta(ORDictionary <TKey, LWWRegister <TValue> > .IDeltaOperation delta)
{
if (delta is LWWDictionaryDelta lwwd)
{
delta = lwwd.Underlying;
}
return(new LWWDictionary <TKey, TValue>(Underlying.MergeDelta(delta)));
}
public void ORDictionary_must_work_with_deltas_and_updates_for_Flag_elements_type()
{
var m1 = ORDictionary.Create(_node1, "a", Flag.False);
var m2 = m1.ResetDelta().AddOrUpdate(_node1, "a", Flag.False, x => x.SwitchOn());
var m3 = ORDictionary <string, Flag> .Empty
.MergeDelta(m1.Delta)
.MergeDelta(m2.Delta);
m3.Entries["a"].Enabled.Should().BeTrue();
}
public void ORDictionary_must_work_with_deltas_and_Increment_for_PNCounter_elements_type()
{
var m1 = ORDictionary.Create(_node1, "a", PNCounter.Empty);
var m2 = m1.ResetDelta().AddOrUpdate(_node1, "a", PNCounter.Empty, x => x.Increment(_node1, 10));
var m3 = m2.ResetDelta().AddOrUpdate(_node2, "a", PNCounter.Empty, x => x.Decrement(_node2, 10));
var m4 = ORDictionary <string, PNCounter> .Empty
.MergeDelta(m1.Delta)
.MergeDelta(m2.Delta)
.MergeDelta(m3.Delta);
m4.Entries["a"].Value.Should().Be(new BigInteger(0));
}
public LWWDictionaryDelta(ORDictionary <TKey, LWWRegister <TValue> > .IDeltaOperation underlying)
{
Underlying = underlying;
if (underlying is IReplicatedDeltaSize s)
{
DeltaSize = s.DeltaSize;
}
else
{
DeltaSize = 1;
}
}
public void ORDictionary_must_have_usual_anomalies_for_remove_with_update_scenario()
{
// please note that the current ORMultiMap has the same anomaly
// because the condition of keeping global vvector is violated
// by removal of the whole entry for the removed key "b" which results in removal of it's value's vvector
var m1 = ORDictionary.Create(_node1, "a", ORSet.Create(_node1, "A")).SetItem(_node1, "b", ORSet.Create(_node1, "B"));
var m2 = ORDictionary.Create(_node2, "c", ORSet.Create(_node2, "C"));
// m1 - node1 gets the update from m2
var merged1 = m1.Merge(m2);
// m2 - node2 gets the update from m1
var merged2 = m2.Merge(m1);
// RACE CONDITION ahead!
var m3 = merged1.ResetDelta().Remove(_node1, "b");
// let's imagine that m3 (node1) update gets propagated here (full state or delta - doesn't matter)
// and is in flight, but in the meantime, an element is being added somewhere else (m4 - node2)
// and the update is propagated before the update from node1 is merged
var m4 = merged2.ResetDelta().AddOrUpdate(_node2, "b", ORSet <string> .Empty, x => x.Add(_node2, "B2"));
// and later merged on node1
var merged3 = m3.Merge(m4);
// and the other way round...
var merged4 = m4.Merge(m3);
// result - the element "B" is kept on both sides...
merged3.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged3.Entries["b"].Elements.Should().BeEquivalentTo("B", "B2");
merged3.Entries["c"].Elements.Should().BeEquivalentTo("C");
merged4.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged4.Entries["b"].Elements.Should().BeEquivalentTo("B", "B2");
merged4.Entries["c"].Elements.Should().BeEquivalentTo("C");
// but if the timing was slightly different, so that the update from node1
// would get merged just before update on node2:
var merged5 = m2.Merge(m3)
.ResetDelta()
.AddOrUpdate(_node2, "b", ORSet <string> .Empty, x => x.Add(_node2, "B2"));
// the update propagated ... and merged on node1:
var merged6 = m3.Merge(merged5);
// then the outcome is different... because the vvector of value("b") was lost...
merged5.Entries["a"].Elements.Should().BeEquivalentTo("A");
// this time it's different...
merged5.Entries["b"].Elements.Should().BeEquivalentTo("B2");
merged5.Entries["c"].Elements.Should().BeEquivalentTo("C");
merged6.Entries["a"].Elements.Should().BeEquivalentTo("A");
// this time it's different...
merged6.Entries["b"].Elements.Should().BeEquivalentTo("B2");
merged6.Entries["c"].Elements.Should().BeEquivalentTo("C");
}
public void ORDictionary_must_not_have_anomalies_for_remove_with_update_scenario_and_deltas_11()
{
var m1 = ORDictionary.Create(_node1, "a", GSet.Create("A"));
var m2 = ORDictionary.Create(_node2, "a", GSet <string> .Empty).Remove(_node2, "a");
var merged1 = m1.Merge(m2);
merged1.Entries["a"].Elements.Should().BeEquivalentTo("A");
var merged2 = m1.MergeDelta(m2.Delta);
merged2.Entries["a"].Elements.Should().BeEquivalentTo("A");
}
public void A_ORDictionary_should_be_able_to_add_entries()
{
var m = ORDictionary.Create(
Tuple.Create(_node1, "a", GSet.Create("A")),
Tuple.Create(_node1, "b", GSet.Create("B")));
Assert.Equal(ImmutableHashSet.Create("A"), m["a"].Elements);
Assert.Equal(ImmutableHashSet.Create("B"), m["b"].Elements);
var m2 = m.SetItem(_node1, "a", GSet.Create("C"));
Assert.Equal(ImmutableHashSet.Create("C"), m2.Entries["a"].Elements);
}
public void ORDictionary_must_be_able_to_add_entries()
{
var m = ORDictionary.Create(
Tuple.Create(_node1, "a", GSet.Create("A")),
Tuple.Create(_node1, "b", GSet.Create("B")));
m["a"].Elements.Should().BeEquivalentTo("A");
m["b"].Elements.Should().BeEquivalentTo("B");
var m2 = m.SetItem(_node1, "a", GSet.Create("C"));
m2.Entries["a"].Elements.Should().BeEquivalentTo("C");
}
public void ORDictionary_must_be_able_to_add_entries_with_delta()
{
var m = ORDictionary.Create(
Tuple.Create(_node1, "a", GSet.Create("A")),
Tuple.Create(_node1, "b", GSet.Create("B")));
var md = m.Delta;
var m1 = ORDictionary <string, GSet <string> > .Empty.MergeDelta(md);
m1.Entries["a"].Should().BeEquivalentTo("A");
m1.Entries["b"].Should().BeEquivalentTo("B");
var m2 = m1.SetItem(_node1, "a", GSet.Create("C"));
m2.Entries["a"].Should().BeEquivalentTo("C");
}
public bool Equals(ORDictionary <TKey, LWWRegister <TValue> > .IDeltaOperation other)
{
if (other is ORDictionary <TKey, LWWRegister <TValue> > .DeltaGroup group)
{
if (Underlying is ORDictionary <TKey, LWWRegister <TValue> > .DeltaGroup ourGroup)
{
return(ourGroup.Operations.SequenceEqual(group.Operations));
}
if (group.Operations.Length == 1)
{
return(Underlying.Equals(group.Operations.First()));
}
return(false);
}
return(Underlying.Equals(other));
}
public void ORDictionary_must_not_have_anomalies_for_remove_with_update_scenario_and_deltas_7()
{
var m1 = ORDictionary.Create(_node1, "a", ORSet.Create(_node1, "A"))
.SetItem(_node1, "b", ORSet.Create(_node1, "B1"))
.Remove(_node1, "b");
var m2 = ORDictionary.Create(_node1, "a", ORSet.Create(_node1, "A"))
.SetItem(_node1, "b", ORSet.Create(_node1, "B2"));
var m2d = m2.ResetDelta().Remove(_node1, "b");
var m2u = m2.ResetDelta()
.AddOrUpdate(_node1, "b", ORSet <string> .Empty, x => x.Add(_node1, "B3"))
.AddOrUpdate(_node2, "b", ORSet <string> .Empty, x => x.Add(_node2, "B4"));
var merged1 = m1.Merge(m2d).MergeDelta(m2u.Delta);
merged1.Entries["a"].Elements.Should().BeEquivalentTo("A");
// note that B1 is lost as it was added and removed earlier in timeline than B2
merged1.Entries["b"].Elements.Should().BeEquivalentTo("B2", "B3", "B4");
}
public void ORDictionary_must_not_have_anomalies_for_remove_with_update_scenario_and_deltas_10()
{
var m1 = ORDictionary.Create(_node1, "a", GSet.Create("A"))
.SetItem(_node2, "b", GSet.Create("B"));
var m3 = m1.ResetDelta().Remove(_node2, "b");
var m4 = m3.ResetDelta()
.SetItem(_node2, "b", GSet.Create("B2"))
.AddOrUpdate(_node2, "b", GSet <string> .Empty, x => x.Add("B3"));
var merged2 = m3.Merge(m4);
merged2.Entries["a"].Should().BeEquivalentTo("A");
merged2.Entries["b"].Should().BeEquivalentTo("B2", "B3");
var merged3 = m3.MergeDelta(m4.Delta);
merged3.Entries["a"].Should().BeEquivalentTo("A");
merged3.Entries["b"].Should().BeEquivalentTo("B2", "B3");
}
public void ORDictionary_must_not_have_anomalies_for_remove_with_update_scenario_and_deltas_6()
{
var m1 = ORDictionary.Create(_node1, "a", ORSet.Create(_node1, "A")).SetItem(_node1, "b", ORSet.Create(_node1, "B"));
var m2 = ORDictionary.Create(_node2, "b", ORSet.Create(_node2, "B3"));
var merged1 = m1.Merge(m2);
var m3 = merged1.ResetDelta().Remove(_node1, "b");
var m4 = merged1.ResetDelta().Remove(_node2, "b")
.AddOrUpdate(_node2, "b", ORSet <string> .Empty, x => x.Add(_node2, "B1"))
.AddOrUpdate(_node2, "b", ORSet <string> .Empty, x => x.Add(_node2, "B2"));
var merged2 = m3.Merge(m4);
merged2.Entries["a"].Elements.Should().BeEquivalentTo("A");
// note that B is not included, because it was removed in both timelines
merged2.Entries["b"].Elements.Should().BeEquivalentTo("B1", "B2");
var merged3 = m3.MergeDelta(m4.Delta);
merged3.Entries["a"].Elements.Should().BeEquivalentTo("A");
// note that B is not included, because it was removed in both timelines
merged3.Entries["b"].Elements.Should().BeEquivalentTo("B1", "B2");
}
public QueryService()
{
this.connection = DataBaseManager.GetInstance().DataBaseConnection;
this.mapping = DataBaseManager.GetInstance().Mapping;
this.rnd = new Random();
}
public LWWDictionary <TKey, TValue> MergeDelta(ORDictionary <TKey, LWWRegister <TValue> > .IDeltaOperation delta) => new LWWDictionary <TKey, TValue>(Underlying.MergeDelta(delta));
/// <summary>
/// TBD
/// </summary>
/// <param name="underlying">TBD</param>
public LWWDictionary(ORDictionary <TKey, LWWRegister <TValue> > underlying)
{
Underlying = underlying;
}
/// <summary>
/// TBD
/// </summary>
/// <param name="cluster">TBD</param>
/// <param name="crdt">TBD</param>
public LocalORDictionary(Cluster.Cluster cluster, ORDictionary <TKey, TVal> crdt) : this(cluster.SelfUniqueAddress, crdt)
{
}
/// <summary>
/// TBD
/// </summary>
/// <param name="currentNode">TBD</param>
/// <param name="crdt">TBD</param>
internal LocalORDictionary(UniqueAddress currentNode, ORDictionary <TKey, TVal> crdt) : this()
{
_currentNode = currentNode;
_crdt = crdt;
}
/// <summary>
/// TBD
/// </summary>
/// <param name="dictionary">TBD</param>
public Surrogate(ORDictionary <TKey, TVal> dictionary)
{
_dictionary = dictionary;
}
/// <summary>
/// Merges data from provided <see cref="ORDictionary{TKey,TValue}"/> into current CRDT,
/// creating new immutable instance in a result.
/// </summary>
/// <param name="dictionary">TBD</param>
/// <returns>TBD</returns>
public LocalORDictionary <TKey, TVal> Merge(ORDictionary <TKey, TVal> dictionary) =>
new LocalORDictionary <TKey, TVal>(_currentNode, _crdt.Merge(dictionary));
public ORDictionary <TKey, TValue> Merge(ORDictionary <TKey, TValue> other)
{
var mergedKeys = KeySet.Merge(other.KeySet);
return(DryMerge(other, mergedKeys, mergedKeys.GetEnumerator()));
}
/// <summary> /// Creates an instance of an ORDictionary scoped to a current cluster. /// </summary> /// <typeparam name="TKey">TBD</typeparam> /// <typeparam name="TVal">TBD</typeparam> /// <param name="cluster">TBD</param> /// <param name="dictionary">TBD</param> /// <returns>TBD</returns> public static LocalORDictionary <TKey, TVal> ORDictionary <TKey, TVal>(this Cluster.Cluster cluster, ORDictionary <TKey, TVal> dictionary) where TVal : IReplicatedData => new LocalORDictionary <TKey, TVal>(cluster, dictionary);
public void ORDictionary_must_work_with_delta_coalescing_scenario_1()
{
var m1 = ORDictionary.Create(_node1, "a", GSet.Create("A")).SetItem(_node1, "b", GSet.Create("B"));
var m2 = m1.ResetDelta()
.SetItem(_node2, "b", GSet.Create("B2"))
.AddOrUpdate(_node2, "b", GSet <string> .Empty, x => x.Add("B3"));
var merged1 = m1.Merge(m2);
merged1.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged1.Entries["b"].Elements.Should().BeEquivalentTo("B", "B2", "B3");
var merged2 = m1.MergeDelta(m2.Delta);
merged2.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged2.Entries["b"].Elements.Should().BeEquivalentTo("B", "B2", "B3");
var m3 = ORDictionary.Create(_node1, "a", GSet.Create("A")).SetItem(_node2, "b", GSet.Create("B"));
var m4 = m3.ResetDelta().SetItem(_node2, "b", GSet.Create("B2")).SetItem(_node2, "b", GSet.Create("B3"));
var merged3 = m3.Merge(m4);
merged3.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged3.Entries["b"].Elements.Should().BeEquivalentTo("B", "B3");
var merged4 = m3.MergeDelta(m4.Delta);
merged4.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged4.Entries["b"].Elements.Should().BeEquivalentTo("B", "B3");
var m5 = ORDictionary.Create(_node1, "a", GSet.Create("A")).SetItem(_node2, "b", GSet.Create("B"));
var m6 = m5.ResetDelta()
.SetItem(_node2, "b", GSet.Create("B2"))
.AddOrUpdate(_node2, "b", GSet <string> .Empty, x => x.Add("B3"))
.AddOrUpdate(_node2, "b", GSet <string> .Empty, x => x.Add("B4"));
var merged5 = m5.Merge(m6);
merged5.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged5.Entries["b"].Elements.Should().BeEquivalentTo("B", "B2", "B3", "B4");
var merged6 = m5.MergeDelta(m6.Delta);
merged6.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged6.Entries["b"].Elements.Should().BeEquivalentTo("B", "B2", "B3", "B4");
var m7 = ORDictionary.Create(_node1, "a", GSet.Create("A")).SetItem(_node2, "b", GSet.Create("B"));
var m8 = m7.ResetDelta()
.SetItem(_node2, "b", GSet.Create("B2"))
.SetItem(_node2, "d", GSet.Create("D"))
.SetItem(_node2, "b", GSet.Create("B3"));
var merged7 = m7.Merge(m8);
merged7.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged7.Entries["b"].Elements.Should().BeEquivalentTo("B", "B3");
merged7.Entries["d"].Elements.Should().BeEquivalentTo("D");
var merged8 = m7.MergeDelta(m8.Delta);
merged8.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged8.Entries["b"].Elements.Should().BeEquivalentTo("B", "B3");
merged8.Entries["d"].Elements.Should().BeEquivalentTo("D");
var m9 = ORDictionary.Create(_node1, "a", GSet.Create("A")).SetItem(_node2, "b", GSet.Create("B"));
var m10 = m9.ResetDelta()
.SetItem(_node2, "b", GSet.Create("B2"))
.SetItem(_node2, "d", GSet.Create("D"))
.Remove(_node2, "d")
.SetItem(_node2, "b", GSet.Create("B3"));
var merged9 = m9.Merge(m10);
merged9.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged9.Entries["b"].Elements.Should().BeEquivalentTo("B", "B3");
var merged10 = m9.MergeDelta(m10.Delta);
merged10.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged10.Entries["b"].Elements.Should().BeEquivalentTo("B", "B3");
}
