public DeltaHashProvider(IDeltaCache deltaCache, ILogger logger, int capacity = 10_000) { _deltaCache = deltaCache; _logger = logger; _deltaHashUpdatesSubject = new ReplaySubject <Cid>(0); var comparer = ComparerBuilder.For <Timestamp>().OrderBy(u => u, descending: true); _capacity = capacity; _hashesByTimeDescending = new SortedList <Timestamp, Cid>(comparer) { Capacity = _capacity }; _hashesByTimeDescending.Add(Timestamp.FromDateTime(DateTime.MinValue.ToUniversalTime()), _deltaCache.GenesisHash); }
public void RecursiveInsertInto([CteContextSource(true, ProviderName.DB2)] string context) { var hierarchyData = GeHirarchyData(); using (var db = GetDataContext(context)) { using (var tree = db.CreateLocalTable(hierarchyData)) using (var resultTable = db.CreateLocalTable <HierarchyData>()) { var hierarchy = GetHierarchyDown(tree, db); hierarchy.Insert(resultTable, r => r); var result = resultTable.OrderBy(h => h.Id); var expected = EnumerateDown(hierarchyData, 0, null).OrderBy(h => h.Id); AreEqual(expected, result, ComparerBuilder <HierarchyData> .GetEqualityComparer()); } } }
public static IEqualityComparer <T> GetEqualityComparer <T>( this MappingSchema mappingSchema, [InstantHandle] Func <ColumnDescriptor, bool> columnPredicate) { if (mappingSchema == null) { throw new ArgumentNullException(nameof(mappingSchema)); } if (columnPredicate == null) { throw new ArgumentNullException(nameof(columnPredicate)); } var cols = new HashSet <MemberAccessor>( mappingSchema.GetEntityDescriptor(typeof(T)).Columns .Where(columnPredicate).Select(c => c.MemberAccessor)); return(ComparerBuilder.GetEqualityComparer <T>(cols.Contains)); }
public void SelectQueryFromList([IncludeDataSources(TestProvName.AllSQLite)] string context) { var items = new[] { new SampleClass { Id = 1, Value = 11 }, new SampleClass { Id = 2, Value = 22 }, new SampleClass { Id = 3, Value = 33 }, new SampleClass { Id = 4, Value = 44 } }; using (var db = GetDataContext(context)) { IQueryable <SampleClass>?itemsQuery = null; for (int i = 0; i < items.Length; i++) { var item = items[i]; var current = i % 2 == 0 ? db.SelectQuery(() => new SampleClass { Id = item.Id, Value = item.Value, }) : db.SelectQuery(() => new SampleClass { Value = item.Value, Id = item.Id, }); itemsQuery = itemsQuery == null ? current : itemsQuery.Concat(current); } var result = itemsQuery !.AsCte().ToArray(); AreEqual(items, result, ComparerBuilder.GetEqualityComparer <SampleClass>()); } }
public void TestUnionAll([IncludeDataSources(TestProvName.AllSQLite)] string context) { var testData = GenerateTestData(); using (var db = GetDataContext(context)) using (var table = db.CreateLocalTable(testData)) { var rs1 = table.Where(t => t.Id % 2 == 0); var rs2 = table.Where(t => t.Id % 4 == 0); var query = rs1.UnionAll(rs2); var e1 = testData.AsQueryable().Where(t => t.Id % 2 == 0); var e2 = testData.AsQueryable().Where(t => t.Id % 4 == 0); var expected = e1.UnionAll(e2).ToArray(); var actual = query.ToArray(); AreEqual(expected, actual, ComparerBuilder.GetEqualityComparer <SampleData>()); } }
public void NonCompileTestLocal([SQLiteDataSources] string context) { Expression <Func <SampleClass, bool> > predicate = c => c.Value > 1; var sampleData = GenerateData(); using (var db = GetDataContext(context)) using (var table = db.CreateLocalTable(sampleData)) { var query = from t in table from t2 in table.Where(predicate) select t; var expected = from t in sampleData from t2 in table.Where(predicate) select t; AreEqual(expected, query, ComparerBuilder <SampleClass> .GetEqualityComparer()); } }
public void LocalInvocation([SQLiteDataSources] string context) { var sampleData = GenerateData(); using (var db = GetDataContext(context)) using (var table = db.CreateLocalTable(sampleData)) { var ids = new[] { 1, 2, 3, 4, 5, 6 }; var query = from t in table where ids.Where(i => i < 3).GroupBy(i => i).Select(i => i.Key).Contains(t.Id) select t; var expected = from t in sampleData where ids.Where(i => i < 3).GroupBy(i => i).Select(i => i.Key).Contains(t.Id) select t; AreEqual(expected, query, ComparerBuilder <SampleClass> .GetEqualityComparer()); } }
public void Custom_comparer_should_be_used_for_collection_when_defined() { Test(() => { var x = _fixture.Create <ComparableObject <int[]> >(); var y = _fixture.Create <ComparableObject <int[]> >(); var referenceComparer = new ComparableObjectEqualityComparer <int[]>(new CustomizableEqualityComparer <int[]>( (a, b) => a is null && b is null || !(a is null || b is null), _ => 0)); var expected = referenceComparer.Equals(x, y); var equalsIsUsed = false; var hashIsUsed = false; var comparer = new ComparerBuilder(c => c .SetDefaultCollectionsOrderIgnoring(_fixture.Create <bool>()) .SetCustomEqualityComparer(new CustomizableEqualityComparer <int>( (__, _) => { equalsIsUsed = true; return(true); }, _ => { hashIsUsed = true; return(0); }))) .GetEqualityComparer <ComparableObject <int[]> >(); var actualEquals = comparer.Equals(x, y); var hashX = comparer.GetHashCode(x); var hashY = comparer.GetHashCode(y); using (new AssertionScope()) { actualEquals.Should().Be(expected); hashX.Should().NotBe(0); hashY.Should().NotBe(0); var fieldIsNull = x.Field is null || y.Field is null; var propertyIsNull = x.Property is null || y.Property is null; var fieldsAreNulls = x.Field is null && y.Field is null; var propertiesAreNulls = x.Property is null && y.Property is null; equalsIsUsed.Should().Be(!fieldIsNull || fieldsAreNulls && !propertyIsNull, $"null checks are used.\n{x}\n{y}"); hashIsUsed.Should().Be(!fieldsAreNulls || !propertiesAreNulls, $"null checks are used.\n{x}\n{y}"); } }); }
public void Enumerable_structs_with_nullables_are_comparable() { var referenceComparer = new CollectionComparer <SampleStruct <int?>?>( new NullableComparer <SampleStruct <int?> >(new SampleStructComparer <int?>())); var comparer = new ComparerBuilder().GetComparer <EnumerableStruct <SampleStruct <int?>?> >(); Helper.Parallel(() => { var x = _fixture.Create <EnumerableStruct <SampleStruct <int?>?> >(); var y = _fixture.Create <EnumerableStruct <SampleStruct <int?>?> >(); var expectedEquals = referenceComparer.Compare(x, y); var equals = comparer.Compare(x, y); using (new AssertionScope()) { comparer.Compare(x, x).Should().Be(0); equals.Should().Be(expectedEquals); } }); }
public async Task DeleteWithOutputAsyncTest([IncludeDataSources(true, TestProvName.AllSqlServer2008Plus)] string context, [Values(100, 200)] int param) { var sourceData = GetSourceData(); using (var db = GetDataContext(context)) using (var source = db.CreateLocalTable(sourceData)) { var expected = source .Where(s => s.Id > 3) .ToArray(); var output = await source .Where(s => s.Id > 3) .DeleteWithOutputAsync(); AreEqual( expected, output, ComparerBuilder.GetEqualityComparer <TableWithData>()); } }
public async Task DeleteWithOutputAsyncTestSingleRecord([IncludeDataSources(true, FeatureDeleteOutputSingle)] string context, [Values(100, 200)] int param) { var sourceData = GetSourceData(); using (var db = GetDataContext(context)) using (var source = db.CreateLocalTable(sourceData)) { var expected = source .Where(s => s.Id == 3) .ToArray(); var output = await source .Where(s => s.Id == 3) .DeleteWithOutputAsync(); AreEqual( expected, output, ComparerBuilder.GetEqualityComparer <TableWithData>()); } }
public void TestExcept([DataSources(ProviderName.SqlServer2000)] string context) { var testData = GenerateTestData(); using (var db = GetDataContext(context)) using (var table = db.CreateLocalTable(testData)) { var rs1 = table.Where(t => t.Id % 2 == 0); rs1 = rs1.Concat(rs1); var rs2 = table.Where(t => t.Id % 4 == 0); var query = rs1.Except(rs2); var e1 = testData.Where(t => t.Id % 2 == 0); e1 = e1.Concat(e1); var e2 = testData.Where(t => t.Id % 4 == 0); var expected = e1.Except(e2).ToArray(); var actual = query.ToArray(); AreEqual(expected, actual, ComparerBuilder.GetEqualityComparer <SampleData>()); } }
public void Test_Patient_SelectAll([IncludeDataSources(TestProvName.AllAccess)] string context) { using (var db = new TestDataConnection(context)) using (db.BeginTransaction()) { var res = Patient_SelectAll(db, context == ProviderName.AccessOdbc); AreEqual( db.Patient.Select(p => new PatientResult() { PersonID = p.Person.ID, FirstName = p.Person.FirstName, LastName = p.Person.LastName, MiddleName = p.Person.MiddleName, Gender = p.Person.Gender, Diagnosis = p.Diagnosis }).OrderBy(_ => _.PersonID), res.OrderBy(_ => _.PersonID), ComparerBuilder.GetEqualityComparer <PatientResult>()); } }
public void After_change_custom_comparer_new_dynamic_comparer_should_be_created() { Test(() => { var x = _fixture.Create <Tuple <int, string> >(); var y = _fixture.Create <Tuple <int, string> >(); var expected1 = x.Item1.CompareTo(y.Item1); var expected2 = x.Item2?.CompareTo(y.Item2) ?? -y.Item2?.CompareTo(null) ?? 0; var builder = new ComparerBuilder(c => c.SetCustomComparer(new CustomizableComparer <string>((__, _) => 0))); var comparer1 = builder.GetComparer <Tuple <int, string> >(); var comparer2 = builder.Configure(c => c.SetCustomComparer <string>(null) .SetCustomComparer(new CustomizableComparer <int>((__, _) => 0))) .GetComparer <Tuple <int, string> >(); using (new AssertionScope()) { comparer1.Compare(x, y).Normalize().Should().Be(expected1.Normalize()); comparer2.Compare(x, y).Normalize().Should().Be(expected2.Normalize()); } }); }
public void Test([IncludeDataSources(ProviderName.SQLite, ProviderName.SQLiteClassic, ProviderName.SQLiteMS)] string context) { var typeId = Guid.NewGuid(); var resources = new[] { new WmsResourceTypeDTO { Depth = 256, Height = 110, Id = typeId, Name = "Resource Name", ShortName = "RN", Width = 333 } }; var carriersA = new[] { new WmsLoadCarrierDTO { Id = Guid.NewGuid(), TypeID = typeId } }; var carriersB = new[] { new WmsLoadCarrierDTO { Id = Guid.NewGuid(), TypeID = typeId } }; using (var db = GetDataContext(context)) using (db.CreateLocalTable <WmsResourceTypeDTO>(resources)) using (db.CreateLocalTable <WmsLoadCarrierDTO>(carriersA)) using (db.CreateLocalTable <WmsLoadCarrierDTO>("WMS_ResourceA", carriersB)) { var qryUnion = from res in db.GetTable <WmsLoadCarrierDTO>().Union(db.GetTable <WmsLoadCarrierDTO>().TableName("WMS_ResourceA")) join type in db.GetTable <WmsResourceTypeDTO>() on res.TypeID equals type.Id into tpList from tp in tpList.DefaultIfEmpty() select new WmsResourceCombinedDTO { LoadCarrier = res, ResourceType = tp }; var staticResult = from res in carriersA.Union(carriersB) join type in resources on res.TypeID equals type.Id into tpList from tp in tpList.DefaultIfEmpty() select new WmsResourceCombinedDTO { LoadCarrier = res, ResourceType = tp }; var actual = qryUnion.ToArray(); var expected = staticResult.ToArray(); AreEqual(expected, actual, ComparerBuilder <WmsResourceCombinedDTO> .GetEqualityComparer()); } }
public void InvocationTestByInvoke([SQLiteDataSources] string context, [Values(1, 2)] int param) { var sampleData = GenerateData(); Expression <Func <int, int, int> > func = (p1, p2) => p1 * 10 + p2 * 2; using (var db = GetDataContext(context)) using (var table = db.CreateLocalTable(sampleData)) { var query = table.AsQueryable(); query.Set(q => q.Value, q => func.Compile()(param, q.Value)).Update(); var compiled = func.Compile(); foreach (var sd in sampleData) { sd.Value = compiled(param, sd.Value); } AreEqual(sampleData, query, ComparerBuilder <SampleClass> .GetEqualityComparer()); } }
public void Compare_enumerables_of_enumerables() { var collectionComparer = new CollectionComparer <List <int?> >(new CollectionComparer <int?>()); var referenceComparer = new CollectionComparer <EnumerableStruct <List <int?> >?>( new NullableComparer <EnumerableStruct <List <int?> > >( new CustomizableComparer <EnumerableStruct <List <int?> > >((a, b) => collectionComparer.Compare(a, b)))); var comparer = new ComparerBuilder().GetComparer <IEnumerable <EnumerableStruct <List <int?> >?> >(); Helper.Parallel(() => { var x = _fixture.CreateMany <EnumerableStruct <List <int?> >?>().RandomNulls().ToList(); var y = _fixture.CreateMany <EnumerableStruct <List <int?> >?>().RandomNulls().ToList(); var expectedEquals = referenceComparer.Compare(x, y); var equals = comparer.Compare(x, y); using (new AssertionScope()) { comparer.Compare(x, x).Should().Be(0); equals.Should().Be(expectedEquals); } }); }
public void DeleteWithOutputTest([IncludeDataSources(true, FeatureDeleteOutputMultiple)] string context, [Values(100, 200)] int param) { var sourceData = GetSourceData(); using (var db = GetDataContext(context)) using (var source = db.CreateLocalTable(sourceData)) { var expected = source .Where(s => s.Id > 3) .ToArray(); var output = source .Where(s => s.Id > 3) .DeleteWithOutput() .ToArray(); AreEqual( expected, output, ComparerBuilder.GetEqualityComparer <TableWithData>()); } }
public void TestConcatInheritance([IncludeDataSources(ProviderName.SQLiteClassic)] string context) { var testData = new BaseEntity[] { new BaseEntity { Discr = 0, EntityId = 1, Value = "VBase1" }, new BaseEntity { Discr = 0, EntityId = 2, Value = "VBase2" }, new BaseEntity { Discr = 0, EntityId = 3, Value = "VBase3" }, new DerivedEntity { Discr = 1, EntityId = 10, Value = "Derived1" }, new DerivedEntity { Discr = 1, EntityId = 20, Value = "Derived2" }, new DerivedEntity { Discr = 1, EntityId = 30, Value = "Derived3" } }; using (var db = GetDataContext(context)) using (db.CreateLocalTable(testData)) { var result = db.GetTable <BaseEntity>().OfType <BaseEntity>() .Concat(db.GetTable <BaseEntity>().OfType <DerivedEntity>()) .ToArray(); var expected = testData.Where(t => t.GetType() == typeof(BaseEntity)) .Concat(testData.OfType <DerivedEntity>()) .ToArray(); AreEqual(expected, result, ComparerBuilder <BaseEntity> .GetEqualityComparer()); } }
public void Should_use_delayed_comparison() { var x = _fixture.CreateMany <SampleEqualityStruct <EnumSmall?>?>().ToArray(); var y = _fixture.CreateMany <SampleEqualityStruct <EnumSmall?>?>().ToArray(); var referenceComparer = new CollectionEqualityComparer <SampleEqualityStruct <EnumSmall?>?>( new NullableEqualityComparer <SampleEqualityStruct <EnumSmall?> >()); var comparer = new ComparerBuilder().GetEqualityComparer <object>(); var expectedHashX = referenceComparer.GetHashCode(x); var expectedHashY = referenceComparer.GetHashCode(y); var actualHashX = comparer.GetHashCode(x); var actualHashY = comparer.GetHashCode(y); var expected = referenceComparer.Equals(x, y); var actual = comparer.Equals(x, y); using (new AssertionScope()) { actualHashX.Should().Be(expectedHashX); actualHashY.Should().Be(expectedHashY); actual.Should().Be(expected); } }
public void After_clean_custom_comparer_for_value_type_dynamic_comparer_should_be_created() { var x = _fixture.Create <ComparableObject <ComparableStruct <string> > >(); var y = _fixture.Create <ComparableObject <ComparableStruct <string> > >(); var reference = new ComparableObjectEqualityComparer <ComparableStruct <string> >(new ComparableStructEqualityComparer <string>()); var expectedEquals = reference.Equals(x, y); var expectedHash = reference.GetHashCode(x); var expectedCustomHash = HashCodeCombiner.Combine(0, 0); var builder = new ComparerBuilder(c => c.SetCustomEqualityComparer <SampleStructCustomEqualityComparer>()); var comparerCustom = builder.GetEqualityComparer <ComparableObject <ComparableStruct <string> > >(); var comparerDefault = builder.Configure(c => c.SetCustomEqualityComparer <ComparableStruct <string> >(null)) .GetEqualityComparer <ComparableObject <ComparableStruct <string> > >(); using (new AssertionScope()) { comparerCustom.Equals(x, y).Should().BeTrue(); comparerCustom.GetHashCode(x).Should().Be(expectedCustomHash); comparerDefault.Equals(x, y).Should().Be(expectedEquals); comparerDefault.GetHashCode(x).Should().Be(expectedHash); } }
public void Custom_comparer_should_be_used_for_collection_when_defined() { Test(() => { var x = _fixture.Create <SampleObject <int[]> >(); var y = _fixture.Create <SampleObject <int[]> >(); var referenceComparer = new SampleObjectComparer <int[]>(new CustomizableComparer <int[]>((a, b) => { if (a == b) { return(0); } if (b is null) { return(1); } if (a is null) { return(-1); } return(0); })); var expected = referenceComparer.Compare(x, y); var comparer = new ComparerBuilder(c => c.SetDefaultCollectionsOrderIgnoring(_fixture.Create <bool>()) .SetCustomComparer(new CustomizableComparer <int>((__, _) => 0))) .GetComparer <SampleObject <int[]> >(); var actual = comparer.Compare(x, y); actual.Should().Be(expected); }); }
public void StringComparer_Null() { var frameworkStringComparer = StringComparer.Ordinal; var frameworkDefaultComparer = EqualityComparer <string> .Default; var nitoStringComparer = ComparerBuilder.For <string>().OrderBy(x => x, StringComparer.Ordinal); // The string comparer allows equating to null Assert.True(frameworkStringComparer.Equals(null, null)); Assert.False(frameworkStringComparer.Equals("test", null)); // But throws if null is passed to GetHashCode // https://github.com/dotnet/corefx/blob/36e812b0e974fa113c50be71e1701735a8a63481/src/Common/src/CoreLib/System/StringComparer.cs#L150-L153 Assert.ThrowsAny <ArgumentException>(() => frameworkStringComparer.GetHashCode(null)); // The framework default comparer does not throw Assert.True(frameworkDefaultComparer.Equals(null, null)); Assert.False(frameworkDefaultComparer.Equals("test", null)); frameworkDefaultComparer.GetHashCode(null); // And neither does the Nito string comparer wrapper. Assert.True(nitoStringComparer.Equals(null, null)); Assert.False(nitoStringComparer.Equals("test", null)); nitoStringComparer.GetHashCode(null); }
public void TestIntersectAll([DataSources] string context) { var testData = GenerateTestData(); using (var db = GetDataContext(context)) using (var table = db.CreateLocalTable(testData)) { var rs1 = table.Where(t => t.Id % 2 == 0); rs1 = rs1.Concat(rs1); var rs2 = table.Where(t => t.Id % 4 == 0); var query = rs1.IntersectAll(rs2); var e1 = testData.Where(t => t.Id % 2 == 0); e1 = e1.Concat(e1); var e2 = testData.Where(t => t.Id % 4 == 0); var expected = e1.Where(e => e2.Contains(e, ComparerBuilder.GetEqualityComparer <SampleData>())).ToArray(); var actual = query.ToArray(); if (!context.Contains(ProviderName.PostgreSQL)) // postgres has a bug? { AreEqual(expected, actual, ComparerBuilder.GetEqualityComparer <SampleData>()); } } }
protected void AreEqualWithComparer <T>(IEnumerable <T> expected, IEnumerable <T> result, Func <MemberAccessor, bool> memberPredicate) { AreEqual(t => t, expected, result, ComparerBuilder.GetEqualityComparer <T>(memberPredicate)); }
protected void AreEqualWithComparer <T>(IEnumerable <T> expected, IEnumerable <T> result) { AreEqual(t => t, expected, result, ComparerBuilder.GetEqualityComparer <T>()); }
public void TestComparerBuilder() { // Create two identical lists, save for the order. IEnumerable<Tester> a = new List<Tester> { new Tester(1, 2), new Tester(14, 432), new Tester(4, 10), new Tester(3, 4), new Tester(10, 12) }; IEnumerable<Tester> b = new List<Tester> { new Tester(1, 2), new Tester(3, 4), new Tester(4, 10), new Tester(10, 12), new Tester(14, 432) }; // Create comparer that compares A then B ComparerBuilder<Tester> comparer = new ComparerBuilder<Tester>((x, y) => (x.A != y.A) ? x.B.CompareTo(y.B) : x.A.CompareTo(y.A)); Assert.IsFalse(b.SequenceEqual(a, comparer)); // Sort using the comparer IOrderedEnumerable<Tester> c = a.OrderBy(t => t, comparer); // Now check sequence equality again Assert.IsTrue(b.SequenceEqual(c, comparer)); }
public void ForElementsOfT_ReturnsBuilderForT_WithoutEnumeratingSequence() { var result = ComparerBuilder.ForElementsOf(ThrowEnumerable()); Assert.IsType <ComparerBuilderFor <int> >(result); }
public void ForT_ReturnsBuilderForT() { var result = ComparerBuilder.For <int>(); Assert.IsType <ComparerBuilderFor <int> >(result); }
/// <summary> /// Sort the element of a queryable sequence by a given sort expression. /// </summary> /// <typeparam name="T">Type of items in sequence.</typeparam> /// <param name="source">Sequence to be sorted.</param> /// <param name="sortExpression">A SQL-like sort expression with comma separated property names (and optional direction specifiers) (e.g. "Age DESC, Name")</param> /// <returns>A queryable object that can enumerate the elements in the input sequence ordered according to the given sort expression.</returns> /// <exception cref="System.ArgumentNullException"><paramref name="source"/> is null or <paramref name="sortExpression"/> is null</exception> /// <exception cref="ParserException">If <paramref name="sortExpression"/> is an invalid sort expression.</exception> public static IOrderedQueryable OrderBy(this IQueryable source, String sortExpression) { return(ComparerBuilder.OrderBy(source.ElementType, source, sortExpression)); }