public void PagingPredicateTest()
{
AssertPredicate(new PagingPredicate(3, Predicates.True()), PredicateDataSerializerHook.PagingPredicate);
AssertPredicate(new PagingPredicate(3, Predicates.True(), new PredicateComparer()), PredicateDataSerializerHook.PagingPredicate);
var paging = new PagingPredicate(3, Predicates.True());
paging.AnchorList.Add(new KeyValuePair <int, KeyValuePair <object, object> >(0, new KeyValuePair <object, object>("a", "b")));
paging.AnchorList.Add(new KeyValuePair <int, KeyValuePair <object, object> >(1, new KeyValuePair <object, object>("c", "d")));
AssertPredicate(paging, PredicateDataSerializerHook.PagingPredicate);
Assert.That(paging.Page, Is.EqualTo(0));
paging.NextPage();
Assert.That(paging.Page, Is.EqualTo(1));
paging.PreviousPage();
Assert.That(paging.Page, Is.EqualTo(0));
paging.PreviousPage();
Assert.That(paging.Page, Is.EqualTo(0));
paging.Reset();
Assert.That(paging.IterationType, Is.Null);
Assert.Throws <ArgumentOutOfRangeException>(() => _ = new PagingPredicate(-1));
Assert.Throws <ArgumentOutOfRangeException>(() => _ = new PagingPredicate(0));
Assert.Throws <ArgumentException>(() => _ = new PagingPredicate(1, new PagingPredicate(1)));
// cannot test reading data as the paging predicate is not really meant to read data
// so we cannot test that writing then reading works, need integration tests for this
Assert.Throws <NotSupportedException>(() => paging.ReadData(new ObjectDataInput(new byte[0], null, Endianness.BigEndian)));
}
private static PagingPredicateHolder BuildHolder(ISerializationService serializationService,
PagingPredicate pagingPredicate, IData partitionKeyData)
{
var anchorList = pagingPredicate.AnchorList;
var anchorDataList = new List <KeyValuePair <IData, IData> >(anchorList.Count);
var pageList = new List <int>(anchorList.Count);
foreach (var pair in anchorList)
{
pageList.Add(pair.Key);
var anchorEntry = pair.Value;
anchorDataList.Add(new KeyValuePair <IData, IData>(serializationService.ToData(anchorEntry.Key),
serializationService.ToData(anchorEntry.Value)));
}
var anchorDataListHolder = new AnchorDataListHolder(pageList, anchorDataList);
var predicateData = serializationService.ToData(pagingPredicate.Predicate);
var comparatorData = serializationService.ToData(pagingPredicate.Comparer);
if (!pagingPredicate.IterationType.HasValue)
{
throw new InvalidOperationException("The paging predicate does not specify an iteration type.");
}
return(new PagingPredicateHolder(anchorDataListHolder, predicateData, comparatorData, pagingPredicate.PageSize,
pagingPredicate.Page, (byte)pagingPredicate.IterationType, partitionKeyData));
}
public virtual void TestValuesPaging_without_comparator_predicate()
{
FillMap();
var predicate = new PagingPredicate(4);
var valuesPage1 = map.Values(predicate);
Assert.That(new[] { "value-0", "value-1", "value-2", "value-3" }, Is.EquivalentTo(valuesPage1.ToArray()));
}
private static PagingPredicate UnwrapPagingPredicate(IPredicate predicate)
{
return(predicate switch
{
PagingPredicate paging => paging,
PartitionPredicate partition => partition.Target as PagingPredicate,
_ => null
});
private static PagingPredicateHolder OfInternal(PagingPredicate pagingPredicate,
ISerializationService serializationService)
{
if (pagingPredicate == null)
{
return(null);
}
return(BuildHolder(serializationService, pagingPredicate, null));
}
public virtual void TestEntrySetPaging_with_comparator()
{
FillMap2();
var predicate = new PagingPredicate(2, null, new CustomComparator(2, IterationType.Entry));
var page1 = map.EntrySet(predicate);
Assert.That(new[] { new KeyValuePair <object, object>("key-65", "A"),
new KeyValuePair <object, object>("key-66", "BB") }, Is.EquivalentTo(page1.ToArray()));
}
public void PagingPredicateHolderTest()
{
var serializationService = new SerializationServiceBuilder(new NullLoggerFactory())
.AddHook <PredicateDataSerializerHook>()
.Build();
var anchorDataListHolder = GetAnchorDataListHolder(serializationService, out var pageList, out var dataList);
var predicateData = new HeapData();
var comparatorData = new HeapData();
var partitionKeyData = new HeapData();
var holder = new PagingPredicateHolder(anchorDataListHolder, predicateData, comparatorData, 5, 12, 3, partitionKeyData);
Assert.That(holder.AnchorDataListHolder, Is.SameAs(anchorDataListHolder));
Assert.That(holder.PredicateData, Is.SameAs(predicateData));
Assert.That(holder.ComparatorData, Is.SameAs(comparatorData));
Assert.That(holder.PageSize, Is.EqualTo(5));
Assert.That(holder.Page, Is.EqualTo(12));
Assert.That(holder.IterationTypeId, Is.EqualTo(3));
Assert.That(holder.PartitionKeyData, Is.SameAs(partitionKeyData));
var predicate = new PagingPredicate(5)
{
IterationType = IterationType.Key
};
predicate.UpdateAnchors(new List <KeyValuePair <int, KeyValuePair <object, object> > >
{
new KeyValuePair <int, KeyValuePair <object, object> >(1, new KeyValuePair <object, object>("key", "value"))
});
holder = PagingPredicateHolder.Of(predicate, serializationService);
Assert.That(holder.PageSize, Is.EqualTo(5));
holder = PagingPredicateHolder.Of(new PartitionPredicate("key", new PagingPredicate(5)
{
IterationType = IterationType.Key
}), serializationService);
Assert.That(holder.PageSize, Is.EqualTo(5));
Assert.That(PagingPredicateHolder.Of(null, serializationService), Is.Null);
Assert.Throws <InvalidOperationException>(() => _ = PagingPredicateHolder.Of(new PagingPredicate(5), serializationService));
Assert.Throws <InvalidOperationException>(() => _ = PagingPredicateHolder.Of(new AndPredicate(), serializationService));
Assert.Throws <InvalidOperationException>(() => _ = PagingPredicateHolder.Of(new PartitionPredicate(), serializationService));
}
public virtual void TestValuesPaging_without_comparator()
{
FillMap();
var predicate = new PagingPredicate(6, Predicates.IsILike("this", "value-%"));
var valuesPage1 = map.Values(predicate);
predicate.NextPage();
var valuesPage2 = map.Values(predicate);
predicate.NextPage();
var valuesPage3 = map.Values(predicate);
Assert.That(new[] { "value-0", "value-1", "value-2", "value-3", "value-4", "value-5" }, Is.EquivalentTo(valuesPage1.ToArray()));
Assert.That(new[] { "value-6", "value-7", "value-8", "value-9" }, Is.EquivalentTo(valuesPage2.ToArray()));
Assert.That(new string[] {}, Is.EquivalentTo(valuesPage3.ToArray()));
}
public virtual void TestKeySetPaging_without_comparator()
{
FillMap();
var predicate = new PagingPredicate(6, Predicates.Key().GreaterThanOrEqual(0));
var keySetPage1 = map.KeySet(predicate);
predicate.NextPage();
var keySetPage2 = map.KeySet(predicate);
predicate.NextPage();
var keySetPage3 = map.KeySet(predicate);
Assert.That(new[] { 0, 1, 2, 3, 4, 5 }, Is.EquivalentTo(keySetPage1.ToArray()));
Assert.That(new[] { 6, 7, 8, 9 }, Is.EquivalentTo(keySetPage2.ToArray()));
Assert.That(new int[] {}, Is.EquivalentTo(keySetPage3.ToArray()));
}
public virtual void TestValuesPaging_without_comparator()
{
FillMap();
var predicate = new PagingPredicate(6, Predicates.IsLessThan("this", 10));
var valuesPage1 = map.Values(predicate);
predicate.NextPage();
var valuesPage2 = map.Values(predicate);
predicate.NextPage();
var valuesPage3 = map.Values(predicate);
Assert.That(new[] { 0, 1, 2, 3, 4, 5 }, Is.EquivalentTo(valuesPage1.ToArray()));
Assert.That(new[] { 6, 7, 8, 9 }, Is.EquivalentTo(valuesPage2.ToArray()));
Assert.That(new int[] {}, Is.EquivalentTo(valuesPage3.ToArray()));
}
public virtual void TestKeySetPaging_without_comparator()
{
FillMap();
var predicate = new PagingPredicate(6, Predicates.Key().ILike("key-%"));
var keySetPage1 = map.KeySet(predicate);
predicate.NextPage();
var keySetPage2 = map.KeySet(predicate);
predicate.NextPage();
var keySetPage3 = map.KeySet(predicate);
Assert.That(new[] { "key-0", "key-1", "key-2", "key-3", "key-4", "key-5" }, Is.EquivalentTo(keySetPage1.ToArray()));
Assert.That(new[] { "key-6", "key-7", "key-8", "key-9" }, Is.EquivalentTo(keySetPage2.ToArray()));
Assert.That(new string[] {}, Is.EquivalentTo(keySetPage3.ToArray()));
}
public virtual void TestEntrySetPaging_without_comparator()
{
FillMap();
var predicate = new PagingPredicate(6, Predicates.IsILike("this", "value-%"));
var page1 = map.EntrySet(predicate);
predicate.NextPage();
var page2 = map.EntrySet(predicate);
predicate.NextPage();
var page3 = map.EntrySet(predicate);
Assert.That(GenerateKeyValuePair(0, 6), Is.EquivalentTo(page1));
Assert.That(GenerateKeyValuePair(6, 10), Is.EquivalentTo(page2));
Assert.That(GenerateKeyValuePair(0, 0), Is.EquivalentTo(page3));
}
public virtual void TestValuePaging_with_comparator()
{
FillMap2();
var predicate = new PagingPredicate(6, null, new CustomComparator(2, IterationType.Value));
var page1 = map.Values(predicate);
predicate.NextPage();
var page2 = map.Values(predicate);
predicate.NextPage();
var page3 = map.Values(predicate);
Assert.That(new[] { "A", "BB", "CCC", "DDDD", "EEEEE", "FFFFFF" }, Is.EquivalentTo(page1.ToArray()));
Assert.That(new[] { "GGGGGGG", "HHHHHHHH", "IIIIIIIII", "JJJJJJJJJJ" }, Is.EquivalentTo(page2.ToArray()));
Assert.That(new string[] {}, Is.EquivalentTo(page3.ToArray()));
}
public virtual void TestKeySetPaging_with_comparator()
{
FillMap();
var predicate = new PagingPredicate(6, Predicates.Key().LessThanOrEqual(10), new CustomComparator(1));
var keySetPage1 = map.KeySet(predicate);
predicate.NextPage();
var keySetPage2 = map.KeySet(predicate);
predicate.NextPage();
var keySetPage3 = map.KeySet(predicate);
Assert.That(new[] { 9, 8, 7, 6, 5, 4 }, Is.EquivalentTo(keySetPage1.ToArray()));
Assert.That(new[] { 3, 2, 1, 0 }, Is.EquivalentTo(keySetPage2.ToArray()));
Assert.That(new int[] {}, Is.EquivalentTo(keySetPage3.ToArray()));
}
public ISet <KeyValuePair <TKey, TValue> > EntrySetWithPagingPredicate(PagingPredicate <TKey, TValue> pagingPredicate)
{
pagingPredicate.SetIterationType(IterationType.ENTRY);
var request = MapEntriesWithPagingPredicateCodec.EncodeRequest(GetName(), ToData(pagingPredicate));
var entries = Invoke(request, m => MapEntriesWithPagingPredicateCodec.DecodeResponse(m).entrySet);
ISet <KeyValuePair <TKey, TValue> > entrySet = new HashSet <KeyValuePair <TKey, TValue> >();
foreach (var dataEntry in entries)
{
var key = ToObject <TKey>(dataEntry.Key);
var value = ToObject <TValue>(dataEntry.Value);
entrySet.Add(new KeyValuePair <TKey, TValue>(key, value));
}
return(SortingUtil.GetSortedQueryResultSet(entrySet, pagingPredicate, IterationType.ENTRY));
}
private static void SetAnchor <TKey, TValue>(IList <KeyValuePair <TKey, TValue> > list,
PagingPredicate pagingPredicate, int nearestPage)
{
if (list.Count == 0)
{
return;
}
var size = list.Count;
var pageSize = pagingPredicate.PageSize;
var page = pagingPredicate.Page;
for (var i = pageSize; i <= size && nearestPage < page; i += pageSize)
{
var anchor = list[i - 1];
nearestPage++;
pagingPredicate.SetAnchor(nearestPage, anchor.Key, anchor.Value);
}
}
public static IEnumerable GetSortedQueryResultSet <TKey, TValue>(List <KeyValuePair <object, object> > list,
PagingPredicate pagingPredicate, IterationType iterationType)
{
if (list.Count == 0)
{
return(new List <KeyValuePair <TKey, TValue> >());
}
var comparator = NewComparer(pagingPredicate.Comparer, iterationType);
list.Sort(comparator);
var nearestAnchorEntry = pagingPredicate.GetNearestAnchorEntry();
var nearestPage = nearestAnchorEntry.Key;
var page = pagingPredicate.Page;
var pageSize = pagingPredicate.PageSize;
var begin = pageSize * (page - nearestPage - 1);
var size = list.Count;
if (begin > size)
{
return(new List <KeyValuePair <TKey, TValue> >());
}
SetAnchor(list, pagingPredicate, nearestPage);
var subList = list.GetRange(begin, Math.Min(pageSize, list.Count - begin));
switch (iterationType)
{
case IterationType.Key:
return(subList.Select(pair => pair.Key));
case IterationType.Value:
return(subList.Select(pair => pair.Value));
case IterationType.Entry:
return(subList.Select(pair => new KeyValuePair <TKey, TValue>((TKey)pair.Key, (TValue)pair.Value)));
default:
throw new ArgumentOutOfRangeException("iterationType", iterationType, null);
}
}
private ISet <TKey> KeySetWithPagingPredicate(PagingPredicate pagingPredicate)
{
pagingPredicate.IterationType = IterationType.Key;
var request = MapKeySetWithPagingPredicateCodec.EncodeRequest(GetName(), ToData(pagingPredicate));
var response = Invoke(request);
var resultParameters = MapKeySetWithPagingPredicateCodec.DecodeResponse(response);
var resultList = new List <KeyValuePair <object, object> >();
foreach (var keyData in resultParameters.response)
{
var key = ToObject <TKey>(keyData);
resultList.Add(new KeyValuePair <object, object>(key, default(TValue)));
}
var resultEnumerator =
SortingUtil.GetSortedQueryResultSet <TKey, TValue>(resultList, pagingPredicate, IterationType.Key);
return(new HashSet <TKey>(resultEnumerator.Cast <TKey>()));
}
private ICollection <TValue> ValuesForPagingPredicate(PagingPredicate pagingPredicate)
{
pagingPredicate.IterationType = IterationType.Value;
var request = MapValuesWithPagingPredicateCodec.EncodeRequest(GetName(), ToData(pagingPredicate));
var response = Invoke(request);
var resultParameters = MapValuesWithPagingPredicateCodec.DecodeResponse(response);
var resultList = new List <KeyValuePair <object, object> >();
foreach (var dataEntry in resultParameters.response)
{
var key = ToObject <TKey>(dataEntry.Key);
var value = ToObject <TValue>(dataEntry.Value);
resultList.Add(new KeyValuePair <object, object>(key, value));
}
var resultEnumerator =
SortingUtil.GetSortedQueryResultSet <TKey, TValue>(resultList, pagingPredicate, IterationType.Value);
return(resultEnumerator.Cast <TValue>().ToList());
}
private static void SetAnchor <TKey, TValue>(List <KeyValuePair <TKey, TValue> > list, PagingPredicate <TKey, TValue> pagingPredicate, int nearestPage)
{
if (list.Count == 0)
{
return;
}
int size = list.Count;
int pageSize = pagingPredicate.GetPageSize();
for (int i = pageSize; i <= size; i += pageSize)
{
KeyValuePair <TKey, TValue> anchor = list[i - 1];
nearestPage++;
pagingPredicate.SetAnchor(nearestPage, anchor);
}
}
public static IComparer <KeyValuePair <TKey, TValue> > NewComparator <TKey, TValue>(PagingPredicate <TKey, TValue> pagingPredicate)
{
return(new SortingComparer <TKey, TValue>(pagingPredicate.GetComparator(), pagingPredicate.GetIterationType()));
}
public static SortedQueryResultSet <TKey, TValue> GetSortedQueryResultSet <TKey, TValue>(ISet <KeyValuePair <TKey, TValue> > list,
PagingPredicate <TKey, TValue> pagingPredicate, IterationType iterationType)
{
if (list == null || list.Count == 0)
{
return(new SortedQueryResultSet <TKey, TValue>());
}
IComparer <KeyValuePair <TKey, TValue> > comparer = SortingUtil.NewComparator(pagingPredicate.GetComparator(), iterationType);
List <KeyValuePair <TKey, TValue> > sortedList = new List <KeyValuePair <TKey, TValue> >();
sortedList.AddRange(list);
sortedList.Sort(comparer);
KeyValuePair <int, KeyValuePair <TKey, TValue> > nearestAnchorEntry = pagingPredicate.GetNearestAnchorEntry();
int nearestPage = nearestAnchorEntry.Key;
int page = pagingPredicate.GetPage();
int pageSize = pagingPredicate.GetPageSize();
int begin = pageSize * (page - nearestPage - 1);
int size = sortedList.Count;
if (begin > size)
{
return(new SortedQueryResultSet <TKey, TValue>());
}
int end = begin + pageSize;
if (end > size)
{
pageSize = size - begin;
}
SetAnchor(sortedList, pagingPredicate, nearestPage);
List <KeyValuePair <TKey, TValue> > subList = sortedList.GetRange(begin, pageSize);
return(new SortedQueryResultSet <TKey, TValue>(comparer, subList, iterationType));
}
