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)); }