diff --git a/ChangeLog/7.1.4_dev.txt b/ChangeLog/7.1.4_dev.txt
new file mode 100644
index 000000000..129c659ad
--- /dev/null
+++ b/ChangeLog/7.1.4_dev.txt
@@ -0,0 +1 @@
+[main] Addressed IndexOutOfRangeException on translation of certain queries with aggregates
\ No newline at end of file
diff --git a/Orm/Xtensive.Orm.PostgreSql/Orm.Providers.PostgreSql/DomainHandler.cs b/Orm/Xtensive.Orm.PostgreSql/Orm.Providers.PostgreSql/DomainHandler.cs
index 6e8bd7a14..961d794f7 100644
--- a/Orm/Xtensive.Orm.PostgreSql/Orm.Providers.PostgreSql/DomainHandler.cs
+++ b/Orm/Xtensive.Orm.PostgreSql/Orm.Providers.PostgreSql/DomainHandler.cs
@@ -9,6 +9,7 @@
using System.Linq;
using Xtensive.Core;
using Xtensive.Orm.Rse.Compilation;
+using Xtensive.Orm.Rse.Transformation;
namespace Xtensive.Orm.Providers.PostgreSql
{
@@ -21,6 +22,12 @@ public class DomainHandler : Providers.DomainHandler
protected override ICompiler CreateCompiler(CompilerConfiguration configuration) =>
new SqlCompiler(Handlers, configuration);
+ protected override IPreCompiler CreatePreCompiler(CompilerConfiguration configuration)
+ {
+ var decimalAggregateCorrector = new AggregateOverDecimalColumnCorrector(Handlers.Domain.Model);
+ return new CompositePreCompiler(decimalAggregateCorrector, base.CreatePreCompiler(configuration));
+ }
+
///
protected override IEnumerable GetProviderCompilerContainers()
{
diff --git a/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0761_ReadingAverageByDecimalField.cs b/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0761_ReadingAverageByDecimalField.cs
deleted file mode 100644
index 87600a632..000000000
--- a/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0761_ReadingAverageByDecimalField.cs
+++ /dev/null
@@ -1,392 +0,0 @@
-// Copyright (C) 2019-2024 Xtensive LLC.
-// This code is distributed under MIT license terms.
-// See the License.txt file in the project root for more information.
-// Created by: Alexey Kulakov
-// Created: 2019.02.14
-
-using System;
-using System.Linq;
-using NUnit.Framework;
-using Xtensive.Orm.Configuration;
-using Xtensive.Orm.Tests.Issues.IssueJira0761_ReadingAverageByDecimalFieldModel;
-
-namespace Xtensive.Orm.Tests.Issues.IssueJira0761_ReadingAverageByDecimalFieldModel
-{
- [HierarchyRoot]
- public class DecimalValueStructureEntityByRefCase : Entity
- {
- [Field, Key]
- public int Id { get; private set; }
-
- [Field]
- public DecimalValueStructureCase Ref { get; set; }
-
- public DecimalValueStructureEntityByRefCase(Session session)
- : base(session)
- {
- }
- }
-
- public class DecimalValueStructure : Structure
- {
- [Field(Precision = 19, Scale = 5)]
- public decimal Value { get; set; }
-
- [Field]
- public int Code { get; set; }
-
- public DecimalValueStructure(Session session)
- : base(session)
- {
- }
- }
-
- [HierarchyRoot]
- public class DecimalValueStructureCase : Entity
- {
- [Field, Key]
- public int Id { get; private set; }
-
- [Field]
- public DecimalValueStructure Struct { get; set; }
-
- [Field(Precision = 19, Scale = 5)]
- public decimal AdditionalValue { get; set; }
-
- public DecimalValueStructureCase(Session session)
- : base(session)
- {
- }
- }
-
- [HierarchyRoot]
- public class KeyValueByEntityRefCase : Entity
- {
- [Field, Key]
- public int Id { get; private set; }
-
- [Field]
- public KeyExpressionCase Ref { get; set; }
-
- public KeyValueByEntityRefCase(Session session)
- : base(session)
- {
- }
- }
-
- [HierarchyRoot]
- public class KeyExpressionCase : Entity
- {
- [Field(Precision = 19, Scale = 5), Key]
- public decimal Id { get; private set; }
-
- [Field]
- public int SomeValue { get; set; }
-
- [Field(Precision = 19, Scale = 5)]
- public decimal AdditionalValue { get; set; }
-
- public KeyExpressionCase(Session session, decimal id)
- : base(session, id)
- {
- }
- }
-
- [HierarchyRoot]
- public class ValueByEntityRefCase : Entity
- {
- [Field, Key]
- public int Id { get; private set; }
-
- [Field]
- public DirectFieldValueCase Ref { get; set; }
-
- public ValueByEntityRefCase(Session session)
- : base(session)
- {
- }
- }
-
- [HierarchyRoot]
- public class DirectFieldValueCase : Entity
- {
- [Field, Key]
- public int Id { get; private set; }
-
- [Field(Precision = 19, Scale = 5)]
- public decimal Accepted { get; set; }
-
- [Field(Precision = 19, Scale = 5)]
- public decimal AdditionalValue { get; set; }
-
- public DirectFieldValueCase(Session session)
- : base(session)
- {
- }
- }
-
- [HierarchyRoot]
- public class Order : Entity
- {
- [Field, Key]
- public int Id { get; private set; }
-
- [Field(Precision = 29, Scale = 2)]
- public decimal Sum { get; set; }
-
- [Field(Precision = 29, Scale = 1)]
- public decimal Sum2 { get; set; }
-
- [Field(Precision = 28, Scale = 2)]
- public decimal Sum3 { get; set; }
-
- [Field(Precision = 27, Scale = 3)]
- public decimal Sum4 { get; set; }
-
- [Field(Precision = 26, Scale = 4)]
- public decimal Sum5 { get; set; }
-
- [Field(Precision = 25, Scale = 5)]
- public decimal Sum6 { get; set; }
-
- [Field(Precision = 24, Scale = 6)]
- public decimal Sum7 { get; set; }
-
- [Field(Precision = 23, Scale = 7)]
- public decimal Sum8 { get; set; }
-
- [Field(Precision = 22, Scale = 8)]
- public decimal Sum9 { get; set; }
-
- [Field(Precision = 21, Scale = 9)]
- public decimal Sum10 { get; set; }
-
- [Field(Precision = 10, Scale = 0)]
- public decimal Count { get; set; }
- }
-}
-
-namespace Xtensive.Orm.Tests.Issues
-{
- public class IssueJira0761_ReadingAverageByDecimalField : AutoBuildTest
- {
- private const int OrderCount = 100;
-
- protected override void CheckRequirements() => Require.ProviderIs(StorageProvider.SqlServer | StorageProvider.PostgreSql);
-
- protected override DomainConfiguration BuildConfiguration()
- {
- var configuration = base.BuildConfiguration();
- configuration.Types.Register(typeof(Order).Assembly, typeof(Order).Namespace);
- configuration.UpgradeMode = DomainUpgradeMode.Recreate;
- return configuration;
- }
-
- protected override void PopulateData()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- for (int i = 0; i < OrderCount; i++) {
- _ = new Order() {
- Sum = (i % 2 == 0) ? 100000000000000000000000000.11m : 100000000000000000000000000.12m,
- Sum2 = 100000000000000000000000000.3m,
- Sum3 = 10000000000000000000000000.33m,
- Sum4 = 100000000000000000000000.333m,
- Sum5 = 1000000000000000000000.3333m,
- Sum6 = 10000000000000000000.33333m,
- Sum7 = 100000000000000000.333333m,
- Sum8 = 1000000000000000.3333333m,
- Sum9 = 10000000000000.33333333m,
- Sum10 = 100000000000.333333333m,
- Count = OrderCount
- };
- }
-
- foreach (var i in Enumerable.Range(1, 1000)) {
- _ = new ValueByEntityRefCase(session) {
- Ref = new DirectFieldValueCase(session) {
- Accepted = 163767
- }
- };
-
- _ = new KeyValueByEntityRefCase(session) {
- Ref = new KeyExpressionCase(session, 163767 + i)
- };
-
- _ = new DecimalValueStructureEntityByRefCase(session) {
- Ref = new DecimalValueStructureCase(session) {
- Struct = new DecimalValueStructure(session) {
- Value = 163767,
- Code = i
- }
- }
- };
- }
-
- tx.Complete();
- }
- }
-
- [Test]
- public void AverageComplexTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryResult = session.Query.All().Average(o => o.Sum);
- var fraction = queryResult - Math.Floor(queryResult);
- Assert.That(fraction, Is.EqualTo(0.11m).Or.EqualTo(0.12m));
-
- queryResult = session.Query.All().Average(o => o.Sum2);
- fraction = queryResult - Math.Floor(queryResult);
- Assert.That(fraction, Is.EqualTo(0.3m));
-
- queryResult = session.Query.All().Average(o => o.Sum3);
- fraction = queryResult - Math.Floor(queryResult);
- Assert.That(fraction, Is.EqualTo(0.33m));
-
- queryResult = session.Query.All().Average(o => o.Sum4);
- fraction = queryResult - Math.Floor(queryResult);
- Assert.That(fraction, Is.EqualTo(0.333m));
-
- queryResult = session.Query.All().Average(o => o.Sum5);
- fraction = queryResult - Math.Floor(queryResult);
- Assert.That(fraction, Is.EqualTo(0.3333m));
-
- queryResult = session.Query.All().Average(o => o.Sum6);
- fraction = queryResult - Math.Floor(queryResult);
- Assert.That(fraction, Is.EqualTo(0.33333m));
-
- queryResult = session.Query.All().Average(o => o.Sum7);
- fraction = queryResult - Math.Floor(queryResult);
- Assert.That(fraction, Is.EqualTo(0.333333m));
-
- queryResult = session.Query.All().Average(o => o.Sum8);
- fraction = queryResult - Math.Floor(queryResult);
- Assert.That(fraction, Is.EqualTo(0.3333333m));
-
- queryResult = session.Query.All().Average(o => o.Sum9);
- fraction = queryResult - Math.Floor(queryResult);
- Assert.That(fraction, Is.EqualTo(0.33333333m));
-
- queryResult = session.Query.All().Average(o => o.Sum10);
- fraction = queryResult - Math.Floor(queryResult);
- Assert.That(fraction, Is.EqualTo(0.333333333m));
- }
- }
-
- [Test]
- public void SumComplexTest()
- {
- Require.ProviderIs(StorageProvider.SqlServer, " MS SQL Server has scale reduction algorithm, PgSql doesn't");
-
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryResult = session.Query.All().Sum(o => o.Sum);
- var localResult = session.Query.All().ToArray().Sum(o => o.Sum);
- Assert.That(queryResult, Is.EqualTo(localResult + 3));
-
- queryResult = session.Query.All().Sum(o => o.Sum2);
- localResult = session.Query.All().ToArray().Sum(o => o.Sum2);
- Assert.That(queryResult, Is.EqualTo(localResult + 6));
-
- queryResult = session.Query.All().Sum(o => o.Sum3);
- localResult = session.Query.All().ToArray().Sum(o => o.Sum3);
- Assert.That(queryResult, Is.EqualTo(localResult + 0.6m));
-
- queryResult = session.Query.All().Sum(o => o.Sum4);
- localResult = session.Query.All().ToArray().Sum(o => o.Sum4);
- Assert.That(queryResult, Is.EqualTo(localResult));
-
- queryResult = session.Query.All().Sum(o => o.Sum5);
- localResult = session.Query.All().ToArray().Sum(o => o.Sum5);
- Assert.That(queryResult, Is.EqualTo(localResult));
-
- queryResult = session.Query.All().Sum(o => o.Sum6);
- localResult = session.Query.All().ToArray().Sum(o => o.Sum6);
- Assert.That(queryResult, Is.EqualTo(localResult));
-
- queryResult = session.Query.All().Sum(o => o.Sum7);
- localResult = session.Query.All().ToArray().Sum(o => o.Sum7);
- Assert.That(queryResult, Is.EqualTo(localResult));
-
- queryResult = session.Query.All().Sum(o => o.Sum8);
- localResult = session.Query.All().ToArray().Sum(o => o.Sum8);
- Assert.That(queryResult, Is.EqualTo(localResult));
-
- queryResult = session.Query.All().Sum(o => o.Sum9);
- localResult = session.Query.All().ToArray().Sum(o => o.Sum9);
- Assert.That(queryResult, Is.EqualTo(localResult));
-
- queryResult = session.Query.All().Sum(o => o.Sum10);
- localResult = session.Query.All().ToArray().Sum(o => o.Sum10);
- Assert.That(queryResult, Is.EqualTo(localResult));
- }
- }
-
- [Test]
- public void DirectFieldValueCase()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var results = session.Query.All().Sum(a => a.Accepted);
- results = session.Query.All().Sum(a => a.Accepted + a.AdditionalValue);
- results = session.Query.All().Sum(a => a.Accepted + 1m);
- }
- }
-
- [Test]
- public void ValueByEntityRefCase()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var results = session.Query.All().Sum(a => a.Ref.Accepted);
- results = session.Query.All().Sum(a => a.Ref.Accepted + a.Ref.AdditionalValue);
- results = session.Query.All().Sum(a => a.Ref.Accepted + 1m);
- }
- }
-
- [Test]
- public void KeyExpressionCase()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var results = session.Query.All().Sum(a => a.Id);
- results = session.Query.All().Sum(a => a.Id + a.AdditionalValue);
- results = session.Query.All().Sum(a => a.Id + 1m);
- }
- }
-
- [Test]
- public void KeyValueByEntityRefCase()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var results = session.Query.All().Sum(a => a.Ref.Id);
- results = session.Query.All().Sum(a => a.Ref.Id + a.Ref.AdditionalValue);
- results = session.Query.All().Sum(a => a.Ref.Id + 1m);
- }
- }
-
- [Test]
- public void DecimalValueStructureCase()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var results = session.Query.All().Sum(a => a.Struct.Value);
- results = session.Query.All().Sum(a => a.Struct.Value + a.AdditionalValue);
- results = session.Query.All().Sum(a => a.Struct.Value + 1m);
- }
- }
-
- [Test]
- public void DecimalValueStructureEntityByRefCase()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var results = session.Query.All().Sum(a => a.Ref.Struct.Value);
- results = session.Query.All().Sum(a => a.Ref.Struct.Value + a.Ref.AdditionalValue);
- results = session.Query.All().Sum(a => a.Ref.Struct.Value + 1m);
- }
- }
- }
-}
\ No newline at end of file
diff --git a/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0761_ReadingAvgAndSumByDecimalField.cs b/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0761_ReadingAvgAndSumByDecimalField.cs
new file mode 100644
index 000000000..eb0e4a818
--- /dev/null
+++ b/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0761_ReadingAvgAndSumByDecimalField.cs
@@ -0,0 +1,490 @@
+// Copyright (C) 2019-2025 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
+// Created by: Alexey Kulakov
+// Created: 2019.02.14
+
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using NUnit.Framework;
+using Xtensive.Orm.Configuration;
+using Xtensive.Orm.Tests.Issues.IssueJira0761_ReadingAvgAndSumByDecimalFieldModel;
+
+namespace Xtensive.Orm.Tests.Issues.IssueJira0761_ReadingAvgAndSumByDecimalFieldModel
+{
+ [HierarchyRoot]
+ public class DecimalValueStructureEntityByRefCase : Entity
+ {
+ [Field, Key]
+ public int Id { get; private set; }
+
+ [Field]
+ public DecimalValueStructureCase Ref { get; set; }
+
+ public DecimalValueStructureEntityByRefCase(Session session)
+ : base(session)
+ {
+ }
+ }
+
+ public class DecimalValueStructure : Structure
+ {
+ [Field(Precision = 19, Scale = 5)]
+ public decimal Value { get; set; }
+
+ [Field]
+ public int Code { get; set; }
+
+ public DecimalValueStructure(Session session)
+ : base(session)
+ {
+ }
+ }
+
+ [HierarchyRoot]
+ public class DecimalValueStructureCase : Entity
+ {
+ [Field, Key]
+ public int Id { get; private set; }
+
+ [Field]
+ public DecimalValueStructure Struct { get; set; }
+
+ [Field(Precision = 19, Scale = 5)]
+ public decimal AdditionalValue { get; set; }
+
+ public DecimalValueStructureCase(Session session)
+ : base(session)
+ {
+ }
+ }
+
+ [HierarchyRoot]
+ public class KeyValueByEntityRefCase : Entity
+ {
+ [Field, Key]
+ public int Id { get; private set; }
+
+ [Field]
+ public KeyExpressionCase Ref { get; set; }
+
+ public KeyValueByEntityRefCase(Session session)
+ : base(session)
+ {
+ }
+ }
+
+ [HierarchyRoot]
+ public class KeyExpressionCase : Entity
+ {
+ [Field(Precision = 19, Scale = 5), Key]
+ public decimal Id { get; private set; }
+
+ [Field]
+ public int SomeValue { get; set; }
+
+ [Field(Precision = 19, Scale = 5)]
+ public decimal AdditionalValue { get; set; }
+
+ public KeyExpressionCase(Session session, decimal id)
+ : base(session, id)
+ {
+ }
+ }
+
+ [HierarchyRoot]
+ public class ValueByEntityRefCase : Entity
+ {
+ [Field, Key]
+ public int Id { get; private set; }
+
+ [Field]
+ public DirectFieldValueCase Ref { get; set; }
+
+ public ValueByEntityRefCase(Session session)
+ : base(session)
+ {
+ }
+ }
+
+ [HierarchyRoot]
+ public class DirectFieldValueCase : Entity
+ {
+ [Field, Key]
+ public int Id { get; private set; }
+
+ [Field(Precision = 19, Scale = 5)]
+ public decimal Accepted { get; set; }
+
+ [Field(Precision = 19, Scale = 5)]
+ public decimal AdditionalValue { get; set; }
+
+ public DirectFieldValueCase(Session session)
+ : base(session)
+ {
+ }
+ }
+
+ [HierarchyRoot]
+ public class Order : Entity
+ {
+ [Field, Key]
+ public int Id { get; private set; }
+
+ [Field(Precision = 29, Scale = 2)]
+ public decimal Sum { get; set; }
+
+ [Field(Precision = 29, Scale = 1)]
+ public decimal Sum2 { get; set; }
+
+ [Field(Precision = 28, Scale = 2)]
+ public decimal Sum3 { get; set; }
+
+ [Field(Precision = 27, Scale = 3)]
+ public decimal Sum4 { get; set; }
+
+ [Field(Precision = 26, Scale = 4)]
+ public decimal Sum5 { get; set; }
+
+ [Field(Precision = 25, Scale = 5)]
+ public decimal Sum6 { get; set; }
+
+ [Field(Precision = 24, Scale = 6)]
+ public decimal Sum7 { get; set; }
+
+ [Field(Precision = 23, Scale = 7)]
+ public decimal Sum8 { get; set; }
+
+ [Field(Precision = 22, Scale = 8)]
+ public decimal Sum9 { get; set; }
+
+ [Field(Precision = 21, Scale = 9)]
+ public decimal Sum10 { get; set; }
+
+ [Field(Precision = 10, Scale = 0)]
+ public decimal Count { get; set; }
+ }
+}
+
+namespace Xtensive.Orm.Tests.Issues
+{
+ public class IssueJira0761_ReadingAvgAndSumByDecimalField : AutoBuildTest
+ {
+ private const int OrderCount = 100;
+
+ private Session globalSession;
+
+ protected override void CheckRequirements() => Require.ProviderIs(StorageProvider.SqlServer | StorageProvider.PostgreSql);
+
+ protected override DomainConfiguration BuildConfiguration()
+ {
+ var configuration = base.BuildConfiguration();
+ configuration.Types.Register(typeof(Order).Assembly, typeof(Order).Namespace);
+ configuration.UpgradeMode = DomainUpgradeMode.Recreate;
+ return configuration;
+ }
+
+ protected override void PopulateData()
+ {
+ var sAndT = CreateSessionAndTransaction();
+ globalSession = sAndT.Item1;
+
+ for (var i = 0; i < OrderCount; i++) {
+ _ = new Order() {
+ Sum = (i % 2 == 0) ? 100000000000000000000000000.11m : 100000000000000000000000000.12m,
+ Sum2 = 100000000000000000000000000.3m,
+ Sum3 = 10000000000000000000000000.33m,
+ Sum4 = 100000000000000000000000.333m,
+ Sum5 = 1000000000000000000000.3333m,
+ Sum6 = 10000000000000000000.33333m,
+ Sum7 = 100000000000000000.333333m,
+ Sum8 = 1000000000000000.3333333m,
+ Sum9 = 10000000000000.33333333m,
+ Sum10 = 100000000000.333333333m,
+ Count = OrderCount
+ };
+ }
+
+ foreach (var i in Enumerable.Range(1, 1000)) {
+ _ = new ValueByEntityRefCase(globalSession) {
+ Ref = new DirectFieldValueCase(globalSession) {
+ Accepted = 163767
+ }
+ };
+
+ _ = new KeyValueByEntityRefCase(globalSession) {
+ Ref = new KeyExpressionCase(globalSession, 163767 + i)
+ };
+
+ _ = new DecimalValueStructureEntityByRefCase(globalSession) {
+ Ref = new DecimalValueStructureCase(globalSession) {
+ Struct = new DecimalValueStructure(globalSession) {
+ Value = 163767,
+ Code = i
+ }
+ }
+ };
+ }
+
+ globalSession.SaveChanges();
+
+#if DEBUG
+ // just to keep data in database
+ sAndT.Item2.Complete();
+#endif
+ }
+
+ #region Avg tests
+
+ [Test]
+ public void AverageComplexTest()
+ {
+ var queryResult = globalSession.Query.All().Average(o => o.Sum);
+ var fraction = queryResult - Math.Floor(queryResult);
+ Assert.That(fraction, Is.EqualTo(0.11m).Or.EqualTo(0.12m));
+
+ queryResult = globalSession.Query.All().Average(o => o.Sum2);
+ fraction = queryResult - Math.Floor(queryResult);
+ Assert.That(fraction, Is.EqualTo(0.3m));
+
+ queryResult = globalSession.Query.All().Average(o => o.Sum3);
+ fraction = queryResult - Math.Floor(queryResult);
+ Assert.That(fraction, Is.EqualTo(0.33m));
+
+ queryResult = globalSession.Query.All().Average(o => o.Sum4);
+ fraction = queryResult - Math.Floor(queryResult);
+ Assert.That(fraction, Is.EqualTo(0.333m));
+
+ queryResult = globalSession.Query.All().Average(o => o.Sum5);
+ fraction = queryResult - Math.Floor(queryResult);
+ Assert.That(fraction, Is.EqualTo(0.3333m));
+
+ queryResult = globalSession.Query.All().Average(o => o.Sum6);
+ fraction = queryResult - Math.Floor(queryResult);
+ Assert.That(fraction, Is.EqualTo(0.33333m));
+
+ queryResult = globalSession.Query.All().Average(o => o.Sum7);
+ fraction = queryResult - Math.Floor(queryResult);
+ Assert.That(fraction, Is.EqualTo(0.333333m));
+
+ queryResult = globalSession.Query.All().Average(o => o.Sum8);
+ fraction = queryResult - Math.Floor(queryResult);
+ Assert.That(fraction, Is.EqualTo(0.3333333m));
+
+ queryResult = globalSession.Query.All().Average(o => o.Sum9);
+ fraction = queryResult - Math.Floor(queryResult);
+ Assert.That(fraction, Is.EqualTo(0.33333333m));
+
+ queryResult = globalSession.Query.All().Average(o => o.Sum10);
+ fraction = queryResult - Math.Floor(queryResult);
+ Assert.That(fraction, Is.EqualTo(0.333333333m));
+ }
+
+ [Test]
+ public void AvgDirectFieldValueCase()
+ {
+ TestAverage(a => a.Accepted);
+ TestAverage(a => a.Accepted + a.AdditionalValue);
+ TestAverage(a => a.Accepted + 1m);
+ }
+
+ [Test]
+ public void AvgValueByEntityRefCase()
+ {
+ TestAverage(a => a.Ref.Accepted);
+ TestAverage(a => a.Ref.Accepted + a.Ref.AdditionalValue);
+ TestAverage(a => a.Ref.Accepted + 1m);
+ }
+
+ [Test]
+ public void AvgKeyExpressionCase()
+ {
+ TestAverage(a => a.Id);
+ TestAverage(a => a.Id + a.AdditionalValue);
+ TestAverage(a => a.Id + 1m);
+ }
+
+ [Test]
+ public void AvgKeyValueByEntityRefCase()
+ {
+ TestAverage(a => a.Ref.Id);
+ TestAverage(a => a.Ref.Id + a.Ref.AdditionalValue);
+ TestAverage(a => a.Ref.Id + 1m);
+ }
+
+ [Test]
+ public void AvgDecimalValueStructureCase()
+ {
+ TestAverage(a => a.Struct.Value);
+ TestAverage(a => a.Struct.Value + a.AdditionalValue);
+ TestAverage(a => a.Struct.Value + 1m);
+ }
+
+ [Test]
+ public void AvgDecimalValueStructureEntityByRefCase()
+ {
+ TestAverage(a => a.Ref.Struct.Value);
+ TestAverage(a => a.Ref.Struct.Value + a.Ref.AdditionalValue);
+ TestAverage(a => a.Ref.Struct.Value + 1m);
+ }
+
+ [Test]
+ public void AvgDecimalExpressionInSourceExpressionsCase()
+ {
+ var results = globalSession.Query.All()
+ .GroupBy(e => e.Id, e => new { Split = e.Accepted * 0.01M })
+ .Select(g => g.Select(x => x.Split).Distinct().Average()).ToList();
+ var localResults = globalSession.Query.All().AsEnumerable()
+ .GroupBy(e => e.Id, e => new { Split = e.Accepted * 0.01M })
+ .Select(g => g.Select(x => x.Split).Distinct().Average()).ToList();
+
+ Assert.That(results.Count, Is.EqualTo(localResults.Count));
+ Assert.That(results.SequenceEqual(localResults), Is.True);
+ }
+
+ private void TestAverage(Expression> selector) where TEntity : Entity
+ {
+ var results = globalSession.Query.All().Average(selector);
+ var localResults = globalSession.Query.All().AsEnumerable().Average(selector.Compile());
+ Assert.That(results, Is.EqualTo(localResults), $"Failed on Average({selector})");
+
+ results = globalSession.Query.All().Select(selector).Average();
+ localResults = globalSession.Query.All().AsEnumerable().Select(selector.Compile()).Average();
+ Assert.That(results, Is.EqualTo(localResults), $"Failed on Select({selector}).Average()");
+
+ results = globalSession.Query.All().Select(selector).Distinct().Average();
+ localResults = globalSession.Query.All().AsEnumerable().Select(selector.Compile()).Distinct().Average();
+ Assert.That(results, Is.EqualTo(localResults), $"Failed on Select({selector}).Distinct().Average()");
+ }
+
+ #endregion
+
+ #region Sum tests
+
+ [Test]
+ public void SumComplexTest()
+ {
+ Require.ProviderIs(StorageProvider.SqlServer, " MS SQL Server has scale reduction algorithm, PgSql doesn't");
+
+ var queryResult = globalSession.Query.All().Sum(o => o.Sum);
+ var localResult = globalSession.Query.All().ToArray().Sum(o => o.Sum);
+ Assert.That(queryResult, Is.EqualTo(localResult + 3));
+
+ queryResult = globalSession.Query.All().Sum(o => o.Sum2);
+ localResult = globalSession.Query.All().ToArray().Sum(o => o.Sum2);
+ Assert.That(queryResult, Is.EqualTo(localResult + 6));
+
+ queryResult = globalSession.Query.All().Sum(o => o.Sum3);
+ localResult = globalSession.Query.All().ToArray().Sum(o => o.Sum3);
+ Assert.That(queryResult, Is.EqualTo(localResult + 0.6m));
+
+ queryResult = globalSession.Query.All().Sum(o => o.Sum4);
+ localResult = globalSession.Query.All().ToArray().Sum(o => o.Sum4);
+ Assert.That(queryResult, Is.EqualTo(localResult));
+
+ queryResult = globalSession.Query.All().Sum(o => o.Sum5);
+ localResult = globalSession.Query.All().ToArray().Sum(o => o.Sum5);
+ Assert.That(queryResult, Is.EqualTo(localResult));
+
+ queryResult = globalSession.Query.All().Sum(o => o.Sum6);
+ localResult = globalSession.Query.All().ToArray().Sum(o => o.Sum6);
+ Assert.That(queryResult, Is.EqualTo(localResult));
+
+ queryResult = globalSession.Query.All().Sum(o => o.Sum7);
+ localResult = globalSession.Query.All().ToArray().Sum(o => o.Sum7);
+ Assert.That(queryResult, Is.EqualTo(localResult));
+
+ queryResult = globalSession.Query.All().Sum(o => o.Sum8);
+ localResult = globalSession.Query.All().ToArray().Sum(o => o.Sum8);
+ Assert.That(queryResult, Is.EqualTo(localResult));
+
+ queryResult = globalSession.Query.All().Sum(o => o.Sum9);
+ localResult = globalSession.Query.All().ToArray().Sum(o => o.Sum9);
+ Assert.That(queryResult, Is.EqualTo(localResult));
+
+ queryResult = globalSession.Query.All().Sum(o => o.Sum10);
+ localResult = globalSession.Query.All().ToArray().Sum(o => o.Sum10);
+ Assert.That(queryResult, Is.EqualTo(localResult));
+ }
+
+ [Test]
+ public void SumDirectFieldValueCase()
+ {
+ TestSum(a => a.Accepted);
+ TestSum(a => a.Accepted + a.AdditionalValue);
+ TestSum(a => a.Accepted + 1m);
+ }
+
+ [Test]
+ public void SumValueByEntityRefCase()
+ {
+ TestSum(a => a.Ref.Accepted);
+ TestSum(a => a.Ref.Accepted + a.Ref.AdditionalValue);
+ TestSum(a => a.Ref.Accepted + 1m);
+ }
+
+ [Test]
+ public void SumKeyExpressionCase()
+ {
+ TestSum(a => a.Id);
+ TestSum(a => a.Id + a.AdditionalValue);
+ TestSum(a => a.Id + 1m);
+ }
+
+ [Test]
+ public void SumKeyValueByEntityRefCase()
+ {
+ TestSum(a => a.Ref.Id);
+ TestSum(a => a.Ref.Id + a.Ref.AdditionalValue);
+ TestSum(a => a.Ref.Id + 1m);
+ }
+
+ [Test]
+ public void SumDecimalValueStructureCase()
+ {
+ TestSum(a => a.Struct.Value);
+ TestSum(a => a.Struct.Value + a.AdditionalValue);
+ TestSum(a => a.Struct.Value + 1m);
+ }
+
+ [Test]
+ public void SumDecimalValueStructureEntityByRefCase()
+ {
+ TestSum(a => a.Ref.Struct.Value);
+ TestSum(a => a.Ref.Struct.Value + a.Ref.AdditionalValue);
+ TestSum(a => a.Ref.Struct.Value + 1m);
+ }
+
+ [Test]
+ public void SumDecimalExpressionInSourceExpressionsCase()
+ {
+ var results = globalSession.Query.All()
+ .GroupBy(e => e.Id, e => new { Split = e.Accepted * 0.01M })
+ .Select(g => g.Select(x => x.Split).Distinct().Sum()).ToList();
+ var localResults = globalSession.Query.All().AsEnumerable()
+ .GroupBy(e => e.Id, e => new { Split = e.Accepted * 0.01M })
+ .Select(g => g.Select(x => x.Split).Distinct().Sum()).ToList();
+
+ Assert.That(results.Count, Is.EqualTo(localResults.Count));
+ Assert.That(results.SequenceEqual(localResults), Is.True);
+ }
+
+ private void TestSum(Expression> selector) where TEntity : Entity
+ {
+ var results = globalSession.Query.All().Sum(selector);
+ var localResults = globalSession.Query.All().AsEnumerable().Sum(selector.Compile());
+ Assert.That(results, Is.EqualTo(localResults), $"Failed on Sum({selector})");
+
+ results = globalSession.Query.All().Select(selector).Sum();
+ localResults = globalSession.Query.All().AsEnumerable().Select(selector.Compile()).Sum();
+ Assert.That(results, Is.EqualTo(localResults), $"Failed on Select({selector}).Sum()");
+
+ results = globalSession.Query.All().Select(selector).Distinct().Sum();
+ localResults = globalSession.Query.All().AsEnumerable().Select(selector.Compile()).Distinct().Sum();
+ Assert.That(results, Is.EqualTo(localResults), $"Failed on Select({selector}).Distinct().Sum()");
+ }
+
+ #endregion
+ }
+}
\ No newline at end of file
diff --git a/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0786/AggregatesProblemTestBase.cs b/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0786/AggregatesProblemTestBase.cs
index 23de857e2..4a8f49cc5 100644
--- a/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0786/AggregatesProblemTestBase.cs
+++ b/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0786/AggregatesProblemTestBase.cs
@@ -21,24 +21,8 @@ public abstract class AggregatesProblemTestBase : AutoBuildTest
protected decimal DoubleValueAccuracy { get; private set; } = 0.00000000000001m;
protected decimal DecimalValueAccuracy { get; private set; } = 0.00000000000000001m;
-
- protected override Domain BuildDomain(DomainConfiguration configuration)
- {
- var firstTryConfig = configuration.Clone();
- firstTryConfig.UpgradeMode = DomainUpgradeMode.Validate;
- try {
- return base.BuildDomain(firstTryConfig);
- }
- catch (SchemaSynchronizationException) { }
- catch (Exception) {
- throw;
- }
-
- refillDatabase = true;
- var secondTryConfig = configuration.Clone();
- secondTryConfig.UpgradeMode = DomainUpgradeMode.Recreate;
- return base.BuildDomain(secondTryConfig);
- }
+ protected Session GlobalSession { get; private set; }
+ protected TransactionScope GlobalTransaction { get; private set; }
protected override DomainConfiguration BuildConfiguration()
{
@@ -62,93 +46,88 @@ protected override void PopulateData()
DecimalValueAccuracy = 0.00001m;
}
- if (!refillDatabase)
- return;
+ (GlobalSession, GlobalTransaction) = CreateSessionAndTransaction();
+ _ = new TestEntity(GlobalSession) {
+ ByteValue = 2,
+ SByteValue = 4,
+ ShortValue = 8,
+ UShortValue = 9,
+ IntValue = 10,
+ UIntValue = 11,
+ LongValue = 20,
+ ULongValue = 25,
+ FloatValue = 0.1f,
+ DecimalValue = 1.2m,
+ DoubleValue1 = 2.0,
+ DoubleValue2 = 3.0,
+ NullableByteValue = 2,
+ NullableSByteValue = 4,
+ NullableShortValue = 8,
+ NullableUShortValue = 9,
+ NullableIntValue = 30,
+ NullableUIntValue = 31,
+ NullableLongValue = 40,
+ NullableULongValue = 45,
+ NullableFloatValue = 0.4f,
+ NullableDecimalValue = 4.2m,
+ NullableDoubleValue1 = 5.0,
+ NullableDoubleValue2 = 6.0
+ };
+ _ = new TestEntity(GlobalSession) {
+ ByteValue = 3,
+ SByteValue = 5,
+ ShortValue = 9,
+ UShortValue = 10,
+ IntValue = 11,
+ UIntValue = 12,
+ LongValue = 21,
+ ULongValue = 26,
+ FloatValue = 0.2f,
+ DecimalValue = 1.3m,
+ DoubleValue1 = 2.1,
+ DoubleValue2 = 3.1,
+ NullableByteValue = 3,
+ NullableSByteValue = 5,
+ NullableShortValue = 9,
+ NullableUShortValue = 10,
+ NullableIntValue = 31,
+ NullableUIntValue = 32,
+ NullableLongValue = 41,
+ NullableULongValue = 46,
+ NullableFloatValue = 0.5f,
+ NullableDecimalValue = 4.3m,
+ NullableDoubleValue1 = 5.1,
+ NullableDoubleValue2 = 6.1
+ };
+ _ = new TestEntity(GlobalSession) {
+ ByteValue = 4,
+ SByteValue = 6,
+ ShortValue = 10,
+ UShortValue = 11,
+ IntValue = 12,
+ UIntValue = 13,
+ LongValue = 22,
+ ULongValue = 27,
+ FloatValue = 0.3f,
+ DecimalValue = 1.4m,
+ DoubleValue1 = 2.3,
+ DoubleValue2 = 3.3,
+ NullableByteValue = 4,
+ NullableSByteValue = 6,
+ NullableShortValue = 10,
+ NullableUShortValue = 11,
+ NullableIntValue = 32,
+ NullableUIntValue = 33,
+ NullableLongValue = 42,
+ NullableULongValue = 47,
+ NullableFloatValue = 0.6f,
+ NullableDecimalValue = 4.4m,
+ NullableDoubleValue1 = 5.3,
+ NullableDoubleValue2 = 6.3
+ };
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- _ = new TestEntity() {
- ByteValue = 2,
- SByteValue = 4,
- ShortValue = 8,
- UShortValue = 9,
- IntValue = 10,
- UIntValue = 11,
- LongValue = 20,
- ULongValue = 25,
- FloatValue = 0.1f,
- DecimalValue = 1.2m,
- DoubleValue1 = 2.0,
- DoubleValue2 = 3.0,
- NullableByteValue = 2,
- NullableSByteValue = 4,
- NullableShortValue = 8,
- NullableUShortValue = 9,
- NullableIntValue = 30,
- NullableUIntValue = 31,
- NullableLongValue = 40,
- NullableULongValue = 45,
- NullableFloatValue = 0.4f,
- NullableDecimalValue = 4.2m,
- NullableDoubleValue1 = 5.0,
- NullableDoubleValue2 = 6.0
- };
- _ = new TestEntity() {
- ByteValue = 3,
- SByteValue = 5,
- ShortValue = 9,
- UShortValue = 10,
- IntValue = 11,
- UIntValue = 12,
- LongValue = 21,
- ULongValue = 26,
- FloatValue = 0.2f,
- DecimalValue = 1.3m,
- DoubleValue1 = 2.1,
- DoubleValue2 = 3.1,
- NullableByteValue = 3,
- NullableSByteValue = 5,
- NullableShortValue = 9,
- NullableUShortValue = 10,
- NullableIntValue = 31,
- NullableUIntValue = 32,
- NullableLongValue = 41,
- NullableULongValue = 46,
- NullableFloatValue = 0.5f,
- NullableDecimalValue = 4.3m,
- NullableDoubleValue1 = 5.1,
- NullableDoubleValue2 = 6.1
- };
- _ = new TestEntity() {
- ByteValue = 4,
- SByteValue = 6,
- ShortValue = 10,
- UShortValue = 11,
- IntValue = 12,
- UIntValue = 13,
- LongValue = 22,
- ULongValue = 27,
- FloatValue = 0.3f,
- DecimalValue = 1.4m,
- DoubleValue1 = 2.3,
- DoubleValue2 = 3.3,
- NullableByteValue = 4,
- NullableSByteValue = 6,
- NullableShortValue = 10,
- NullableUShortValue = 11,
- NullableIntValue = 32,
- NullableUIntValue = 33,
- NullableLongValue = 42,
- NullableULongValue = 47,
- NullableFloatValue = 0.6f,
- NullableDecimalValue = 4.4m,
- NullableDoubleValue1 = 5.3,
- NullableDoubleValue2 = 6.3
- };
-
- tx.Complete();
- }
+ GlobalSession.SaveChanges();
}
}
}
\ No newline at end of file
diff --git a/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0786/AverageProcessingTest.cs b/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0786/AverageProcessingTest.cs
index bff74112a..6378f412c 100644
--- a/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0786/AverageProcessingTest.cs
+++ b/Orm/Xtensive.Orm.Tests/Issues/AggregatesRelatedIssues/IssueJira0786/AverageProcessingTest.cs
@@ -1,4 +1,4 @@
-// Copyright (C) 2020-2024 Xtensive LLC.
+// Copyright (C) 2020-2025 Xtensive LLC.
// This code is distributed under MIT license terms.
// See the License.txt file in the project root for more information.
// Created by: Alexey Kulakov
@@ -7,3023 +7,1310 @@
using NUnit.Framework;
using System;
using System.Linq;
+using System.Linq.Expressions;
namespace Xtensive.Orm.Tests.Issues.IssueJira0786_AggregatesProblem
{
public sealed class AverageProcessingTest : AggregatesProblemTestBase
{
[Test]
- public void ByteFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldTest() => TestAverage(i => i.ByteValue);
[Test]
- public void SByteFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldTest() => TestAverage(i => i.SByteValue);
[Test]
- public void ShortFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.ShortValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.ShortValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ShortFieldTest() => TestAverage(i => i.ShortValue);
[Test]
- public void UShortFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.UShortValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.UShortValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void UShortFieldTest() => TestAverage(i => i.UShortValue);
[Test]
- public void IntFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void IntFieldTest() => TestAverage(i => i.IntValue);
[Test]
- public void UIntFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.UIntValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.UIntValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void UIntFieldTest() => TestAverage(i => i.UIntValue);
[Test]
- public void LongFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void LongFieldTest() => TestAverage(i => i.LongValue);
[Test]
- public void FloatFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.FloatValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.FloatValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void FloatFieldTest() => TestAverage(i => i.FloatValue);
[Test]
- public void DoubleFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.DoubleValue1 + 1.0);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.DoubleValue1 + 1.0);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void DoubleFieldTest() => TestAverage(i => i.DoubleValue1 + 1.0);
[Test]
- public void DecimalFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.DecimalValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.DecimalValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void DecimalFieldTest() => TestAverage(i => i.DecimalValue);
[Test]
- public void NullableByteFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.NullableByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.NullableByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void NullableByteFieldTest() => TestAverage(i => i.NullableByteValue);
[Test]
- public void NullableSByteFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.NullableSByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.NullableSByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void NullableSByteFieldTest() => TestAverage(i => i.NullableSByteValue);
[Test]
- public void NullableShortFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.NullableShortValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.NullableShortValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void NullableShortFieldTest() => TestAverage(i => i.NullableShortValue);
[Test]
- public void NullableUShortFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.NullableUShortValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.NullableUShortValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void NullableUShortFieldTest() => TestAverage(i => i.NullableUShortValue);
[Test]
- public void NullableIntFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.NullableByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.NullableByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void NullableIntFieldTest() => TestAverage(i => i.NullableIntValue);
[Test]
- public void NullableUIntFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.NullableUIntValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.NullableUIntValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void NullableUIntFieldTest() => TestAverage(i => i.NullableUIntValue);
[Test]
- public void NullableLongFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.NullableByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.NullableByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void NullableLongFieldTest() => TestAverage(i => i.NullableLongValue);
[Test]
- public void NullableFloatFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.NullableFloatValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.NullableFloatValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void NullableFloatFieldTest() => TestAverage(i => i.NullableFloatValue);
[Test]
- public void NullableDoubleFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.NullableDoubleValue1);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.NullableDoubleValue1);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void NullableDoubleFieldTest() => TestAverage(i => i.NullableDoubleValue1);
[Test]
- public void NullableDecimalFieldTest()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.NullableDecimalValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.NullableDecimalValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void NullableDecimalFieldTest() => TestAverage(i => i.NullableDecimalValue);
[Test]
- public void ByteFieldExpressionTest01()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.ByteValue + i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.ByteValue + i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest01() => TestAverage(i => i.ByteValue + i.ByteValue);
[Test]
- public void ByteFieldExpressionTest02()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (short) i.ByteValue + i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (short) i.ByteValue + i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest02() =>
+ TestAverage(i => (short) i.ByteValue + i.ByteValue);
[Test]
- public void ByteFieldExpressionTest03()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (short) i.ByteValue + (short) i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (short) i.ByteValue + (short) i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest03() =>
+ TestAverage(i => (short) i.ByteValue + (short) i.ByteValue);
[Test]
- public void ByteFieldExpressionTest04()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (int) i.ByteValue + i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (int) i.ByteValue + i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest04() =>
+ TestAverage(i => (int) i.ByteValue + i.ByteValue);
[Test]
- public void ByteFieldExpressionTest05()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (int) i.ByteValue + (int) i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (int) i.ByteValue + (int) i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest05() =>
+ TestAverage(i => (int) i.ByteValue + (int) i.ByteValue);
[Test]
- public void ByteFieldExpressionTest06()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (long) i.ByteValue + i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (long) i.ByteValue + i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest06() =>
+ TestAverage(i => (long) i.ByteValue + i.ByteValue);
[Test]
- public void ByteFieldExpressionTest07()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (long) i.ByteValue + (long) i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (long) i.ByteValue + (long) i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest07() =>
+ TestAverage(i => (long) i.ByteValue + (long) i.ByteValue);
[Test]
- public void ByteFieldExpressionTest08()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (float) i.ByteValue + i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (float) i.ByteValue + i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest08() =>
+ TestAverage(i => (float) i.ByteValue + i.ByteValue);
[Test]
- public void ByteFieldExpressionTest09()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (float) i.ByteValue + (float) i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (float) i.ByteValue + (float) i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest09() =>
+ TestAverage(i => (float) i.ByteValue + (float) i.ByteValue);
[Test]
- public void ByteFieldExpressionTest10()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (double) i.ByteValue + i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (double) i.ByteValue + i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest10() =>
+ TestAverage(i => (double) i.ByteValue + i.ByteValue);
[Test]
- public void ByteFieldExpressionTest11()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (double) i.ByteValue + (double) i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (double) i.ByteValue + (double) i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest11() =>
+ TestAverage(i => (double) i.ByteValue + (double) i.ByteValue);
[Test]
- public void ByteFieldExpressionTest12()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (decimal) i.ByteValue + i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (decimal) i.ByteValue + i.ByteValue);
- Assert.That(Math.Abs(queryableResult - decimal.Round(enumerableResult, 19)), Is.LessThan(DecimalValueAccuracy));
- }
- }
+ public void ByteFieldExpressionTest12() =>
+ TestAverageWithAccuracy(i => (decimal) i.ByteValue + i.ByteValue);
[Test]
- public void ByteFieldExpressionTest13()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (decimal) i.ByteValue + (decimal) i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (decimal) i.ByteValue + (decimal) i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest13() =>
+ TestAverage(i => (decimal) i.ByteValue + (decimal) i.ByteValue);
[Test]
- public void ByteFieldExpressionTest14()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.ByteValue + i.IntValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.ByteValue + i.IntValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest14() => TestAverage(i => i.ByteValue + i.IntValue);
[Test]
- public void ByteFieldExpressionTest15()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.ByteValue + i.LongValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.ByteValue + i.LongValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest15() => TestAverage(i => i.ByteValue + i.LongValue);
[Test]
- public void ByteFieldExpressionTest16()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.ByteValue + i.FloatValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.ByteValue + i.FloatValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest16() => TestAverage(i => i.ByteValue + i.FloatValue);
[Test]
- public void ByteFieldExpressionTest17()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.ByteValue + i.DoubleValue1);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.ByteValue + i.DoubleValue1);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest17() => TestAverage(i => i.ByteValue + i.DoubleValue1);
[Test]
- public void ByteFieldExpressionTest18()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.ByteValue + i.DecimalValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.ByteValue + i.DecimalValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ByteFieldExpressionTest18() => TestAverage(i => i.ByteValue + i.DecimalValue);
[Test]
- public void SByteFieldExpressionTest01()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.SByteValue + i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.SByteValue + i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest01() => TestAverage(i => i.SByteValue + i.SByteValue);
[Test]
- public void SByteFieldExpressionTest02()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (short) i.SByteValue + i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (short) i.SByteValue + i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest02() =>
+ TestAverage(i => (short) i.SByteValue + i.SByteValue);
[Test]
- public void SByteFieldExpressionTest03()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (short) i.SByteValue + (short) i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (short) i.SByteValue + (short) i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest03() =>
+ TestAverage(i => (short) i.SByteValue + (short) i.SByteValue);
[Test]
- public void SByteFieldExpressionTest04()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (int) i.SByteValue + i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (int) i.SByteValue + i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest04() =>
+ TestAverage(i => (int) i.SByteValue + i.SByteValue);
[Test]
- public void SByteFieldExpressionTest05()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (int) i.SByteValue + (int) i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (int) i.SByteValue + (int) i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest05() =>
+ TestAverage(i => (int) i.SByteValue + (int) i.SByteValue);
[Test]
- public void SByteFieldExpressionTest06()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (long) i.SByteValue + i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (long) i.SByteValue + i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest06() =>
+ TestAverage(i => (long) i.SByteValue + i.SByteValue);
[Test]
- public void SByteFieldExpressionTest07()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (long) i.SByteValue + (long) i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (long) i.SByteValue + (long) i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest07() =>
+ TestAverage(i => (long) i.SByteValue + (long) i.SByteValue);
[Test]
- public void SByteFieldExpressionTest08()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (float) i.SByteValue + i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (float) i.SByteValue + i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest08() =>
+ TestAverage(i => (float) i.SByteValue + i.SByteValue);
[Test]
- public void SByteFieldExpressionTest09()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (float) i.SByteValue + (float) i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (float) i.SByteValue + (float) i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest09() =>
+ TestAverage(i => (float) i.SByteValue + (float) i.SByteValue);
[Test]
- public void SByteFieldExpressionTest10()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (double) i.SByteValue + i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (double) i.SByteValue + i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest10() =>
+ TestAverage(i => (double) i.SByteValue + i.SByteValue);
[Test]
- public void SByteFieldExpressionTest11()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (double) i.SByteValue + (double) i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (double) i.SByteValue + (double) i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest11() =>
+ TestAverage(i => (double) i.SByteValue + (double) i.SByteValue);
[Test]
- public void SByteFieldExpressionTest12()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (decimal) i.SByteValue + i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (decimal) i.SByteValue + i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest12() =>
+ TestAverage(i => (decimal) i.SByteValue + i.SByteValue);
[Test]
- public void SByteFieldExpressionTest13()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (decimal) i.SByteValue + (decimal) i.SByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (decimal) i.SByteValue + (decimal) i.SByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest13() =>
+ TestAverage(i => (decimal) i.SByteValue + (decimal) i.SByteValue);
[Test]
- public void SByteFieldExpressionTest14()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.SByteValue + i.ByteValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.SByteValue + i.ByteValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest14() => TestAverage(i => i.SByteValue + i.ByteValue);
[Test]
- public void SByteFieldExpressionTest15()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.SByteValue + i.IntValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.SByteValue + i.IntValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest15() => TestAverage(i => i.SByteValue + i.IntValue);
[Test]
- public void SByteFieldExpressionTest16()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.SByteValue + i.LongValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.SByteValue + i.LongValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest16() => TestAverage(i => i.SByteValue + i.LongValue);
[Test]
- public void SByteFieldExpressionTest17()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.SByteValue + i.FloatValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.SByteValue + i.FloatValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest17() => TestAverage(i => i.SByteValue + i.FloatValue);
[Test]
- public void SByteFieldExpressionTest18()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.SByteValue + i.DoubleValue1);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.SByteValue + i.DoubleValue1);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest18() => TestAverage(i => i.SByteValue + i.DoubleValue1);
[Test]
- public void SByteFieldExpressionTest19()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.SByteValue + i.DecimalValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.SByteValue + i.DecimalValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void SByteFieldExpressionTest19() => TestAverage(i => i.SByteValue + i.DecimalValue);
[Test]
- public void ShortFieldExpressionTest01()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => i.ShortValue + i.ShortValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => i.ShortValue + i.ShortValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ShortFieldExpressionTest01() => TestAverage(i => i.ShortValue + i.ShortValue);
[Test]
- public void ShortFieldExpressionTest02()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All().Average(i => (int) i.ShortValue + i.ShortValue);
- var enumerableResult = session.Query.All().AsEnumerable().Average(i => (int) i.ShortValue + i.ShortValue);
- Assert.That(queryableResult, Is.EqualTo(enumerableResult));
- }
- }
+ public void ShortFieldExpressionTest02() =>
+ TestAverage(i => (int) i.ShortValue + i.ShortValue);
[Test]
- public void ShortFieldExpressionTest03()
- {
- using (var session = Domain.OpenSession())
- using (var tx = session.OpenTransaction()) {
- var queryableResult = session.Query.All