CSHARP-5675: Where possible, return null for average over the empty set (#1755)

ajcvickers · web-flow · commit 22204b5ae550 · 2025-09-22T10:03:22.000+01:00
* CSHARP-5675: Where possible, return null for average over the empty set Fixes [CSHARP-5675: Average over empty collection of nullable types throws](https://jira.mongodb.org/browse/CSHARP-5675) For the terminating operator, the fix is to use the SingleOrDefault finalizer when the type is nullable. * Review feedback.
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToExecutableQueryTranslators/AverageMethodToExecutableQueryTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToExecutableQueryTranslators/AverageMethodToExecutableQueryTranslator.cs
@@ -36,7 +36,8 @@ internal static class AverageMethodToExecutableQueryTranslator<TOutput>
         // private static fields
         private static readonly MethodInfo[] __averageMethods;
         private static readonly MethodInfo[] __averageWithSelectorMethods;
-        private static readonly IExecutableQueryFinalizer<TOutput, TOutput> __finalizer = new SingleFinalizer<TOutput>();
+        private static readonly IExecutableQueryFinalizer<TOutput, TOutput> __singleFinalizer = new SingleFinalizer<TOutput>();
+        private static readonly IExecutableQueryFinalizer<TOutput, TOutput> __singleOrDefaultFinalizer = new SingleOrDefaultFinalizer<TOutput>();
 
         // static constructor
         static AverageMethodToExecutableQueryTranslator()
@@ -138,11 +139,11 @@ public static ExecutableQuery<TDocument, TOutput> Translate<TDocument>(MongoQuer
 
                 IBsonSerializer outputValueSerializer = expression.GetResultType() switch
                 {
-                    Type t when t == typeof(int) => new Int32Serializer(),
-                    Type t when t == typeof(long) => new Int64Serializer(),
-                    Type t when t == typeof(float) => new SingleSerializer(),
-                    Type t when t == typeof(double) => new DoubleSerializer(),
-                    Type t when t == typeof(decimal) => new DecimalSerializer(),
+                    Type t when t == typeof(int) => Int32Serializer.Instance,
+                    Type t when t == typeof(long) => Int64Serializer.Instance,
+                    Type t when t == typeof(float) => SingleSerializer.Instance,
+                    Type t when t == typeof(double) => DoubleSerializer.Instance,
+                    Type t when t == typeof(decimal) => DecimalSerializer.Instance,
                     Type { IsConstructedGenericType: true } t when t.GetGenericTypeDefinition() == typeof(Nullable<>) => (IBsonSerializer)Activator.CreateInstance(typeof(NullableSerializer<>).MakeGenericType(t.GenericTypeArguments[0])),
                     _ => throw new ExpressionNotSupportedException(expression)
                 };
@@ -155,10 +156,14 @@ public static ExecutableQuery<TDocument, TOutput> Translate<TDocument>(MongoQuer
                     AstStage.Project(AstProject.ExcludeId()),
                     outputWrappedValueSerializer);
 
+                var returnType = expression.Type;
+
                 return ExecutableQuery.Create(
                     provider,
                     pipeline,
-                    __finalizer);
+                    returnType.IsNullable() // Note: numeric types are never reference types
+                        ? __singleOrDefaultFinalizer
+                        : __singleFinalizer);
             }
 
             throw new ExpressionNotSupportedException(expression);
diff --git a/tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/AverageMethodToAggregationExpressionTranslatorTests.cs b/tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/AverageMethodToAggregationExpressionTranslatorTests.cs
@@ -13,6 +13,7 @@
 * limitations under the License.
 */
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using FluentAssertions;
@@ -391,6 +392,112 @@ public void Average_with_nullable_longs_selector_should_work(
             results.Should().Equal(null, null, 4.0);
         }
 
+        [Theory]
+        [ParameterAttributeData]
+        public void Average_over_empty_set_of_nullable_values_should_work(
+            [Values(false, true)] bool withNestedAsQueryable)
+        {
+            var collection = Fixture.Collection;
+
+            var queryable = withNestedAsQueryable ?
+                collection.AsQueryable().Select(x => x.EmptyNullableDecimals.AsQueryable().Average()) :
+                collection.AsQueryable().Select(x => x.EmptyNullableDecimals.Average());
+
+            var stages = Translate(collection, queryable);
+            AssertStages(stages, "{ $project : { _v : { $avg : '$EmptyNullableDecimals' }, _id : 0 } }");
+
+            var results = queryable.ToList();
+            results.Should().Equal(null, null, null);
+        }
+
+        [Theory]
+        [ParameterAttributeData]
+        public void Average_with_selector_over_empty_set_of_nullable_values_should_work(
+            [Values(false, true)] bool withNestedAsQueryable)
+        {
+            var collection = Fixture.Collection;
+
+            var queryable = withNestedAsQueryable ?
+                collection.AsQueryable().Select(x => x.EmptyNullableDecimals.AsQueryable().Average(x => x * 2.0M)) :
+                collection.AsQueryable().Select(x => x.EmptyNullableDecimals.Average(x => x * 2.0M));
+
+            var stages = Translate(collection, queryable);
+            AssertStages(stages, "{ $project : { _v : { $avg : { $map : { input : '$EmptyNullableDecimals', as : 'x', in : { $multiply : ['$$x', NumberDecimal(2)] } } } }, _id : 0 } }");
+
+            var results = queryable.ToList();
+            results.Should().Equal(null, null, null);
+        }
+
+        [Theory]
+        [ParameterAttributeData]
+        public void Average_over_empty_set_of_non_nullable_values_should_throw(
+            [Values(false, true)] bool withNestedAsQueryable)
+        {
+            var collection = Fixture.Collection;
+
+            var queryable = withNestedAsQueryable ?
+                collection.AsQueryable().Select(x => x.EmptyDecimals.AsQueryable().Average()) :
+                collection.AsQueryable().Select(x => x.EmptyDecimals.Average());
+
+            var stages = Translate(collection, queryable);
+            AssertStages(stages, "{ $project : { _v : { $avg : '$EmptyDecimals' }, _id : 0 } }");
+
+            Assert.Throws<FormatException>(() => queryable.ToList());
+        }
+
+        [Theory]
+        [ParameterAttributeData]
+        public void Average_with_selector_over_empty_set_of_non_nullable_values_should_throw(
+            [Values(false, true)] bool withNestedAsQueryable)
+        {
+            var collection = Fixture.Collection;
+
+            var queryable = withNestedAsQueryable ?
+                collection.AsQueryable().Select(x => x.EmptyDecimals.AsQueryable().Average(x => x * 2.0M)) :
+                collection.AsQueryable().Select(x => x.EmptyDecimals.Average(x => x * 2.0M));
+
+            var stages = Translate(collection, queryable);
+            AssertStages(stages, "{ $project : { _v : { $avg : { $map : { input : '$EmptyDecimals', as : 'x', in : { $multiply : ['$$x', NumberDecimal(2)] } } } }, _id : 0 } }");
+
+            Assert.Throws<FormatException>(() => queryable.ToList());
+        }
+
+        [Theory]
+        [ParameterAttributeData]
+        public void Average_over_empty_set_of_non_nullable_values_cast_to_nullable_should_work(
+            [Values(false, true)] bool withNestedAsQueryable)
+        {
+            var collection = Fixture.Collection;
+
+            var queryable = withNestedAsQueryable ?
+                collection.AsQueryable().Select(x => x.EmptyDecimals.Select(e => (decimal?)e).AsQueryable().Average()) :
+                collection.AsQueryable().Select(x => x.EmptyDecimals.Select(e => (decimal?)e).Average());
+
+            var stages = Translate(collection, queryable);
+            AssertStages(stages, "{ $project : { _v : { $avg : { $map : { input : '$EmptyDecimals', as : 'e', in : '$$e' } } }, _id : 0 } }");
+
+            var results = queryable.ToList();
+            results.Should().Equal(null, null, null);
+        }
+
+        [Theory]
+        [ParameterAttributeData]
+        public void Average_with_selector_over_empty_set_of_non_nullable_values_cast_to_nullable_should_work(
+            [Values(false, true)] bool withNestedAsQueryable)
+        {
+            var collection = Fixture.Collection;
+
+            var queryable = withNestedAsQueryable ?
+                collection.AsQueryable().Select(x => x.EmptyDecimals.Select(e => (decimal?)e).AsQueryable().Average(x => x * 2.0M)) :
+                collection.AsQueryable().Select(x => x.EmptyDecimals.Select(e => (decimal?)e).Average(x => x * 2.0M));
+
+            var stages = Translate(collection, queryable);
+            AssertStages(stages, "{ $project : { _v : { $avg : { $map : { input : { $map : { input : '$EmptyDecimals', as : 'e', in : '$$e' } }, as : 'x', in : { $multiply : ['$$x', { '$numberDecimal' : '2.0' }] } } } }, _id : 0 } }");
+
+            var results = queryable.ToList();
+            results.Should().Equal(null, null, null);
+        }
+
         public class C
         {
             public int Id { get; set; }
@@ -404,6 +511,8 @@ public class C
             public float?[] NullableFloats { get; set; }
             public int?[] NullableInts { get; set; }
             public long?[] NullableLongs { get; set; }
+            [BsonRepresentation(BsonType.Decimal128)] public decimal[] EmptyDecimals { get; set; }
+            [BsonRepresentation(BsonType.Decimal128)] public decimal?[] EmptyNullableDecimals { get; set; }
         }
 
         public sealed class ClassFixture : MongoCollectionFixture<C>
@@ -422,7 +531,9 @@ public sealed class ClassFixture : MongoCollectionFixture<C>
                     NullableDoubles = new double?[0] { },
                     NullableFloats = new float?[0] { },
                     NullableInts = new int?[0] { },
-                    NullableLongs = new long?[0] { }
+                    NullableLongs = new long?[0] { },
+                    EmptyDecimals = [],
+                    EmptyNullableDecimals = []
                 },
                 new C
                 {
@@ -436,7 +547,9 @@ public sealed class ClassFixture : MongoCollectionFixture<C>
                     NullableDoubles = new double?[] { null },
                     NullableFloats = new float?[] { null },
                     NullableInts = new int?[] { null },
-                    NullableLongs = new long?[] { null }
+                    NullableLongs = new long?[] { null },
+                    EmptyDecimals = [],
+                    EmptyNullableDecimals = []
                 },
                 new C
                 {
@@ -450,7 +563,9 @@ public sealed class ClassFixture : MongoCollectionFixture<C>
                     NullableDoubles = new double?[] { null, 1.0, 2.0, 3.0 },
                     NullableFloats = new float?[] { null, 1.0F, 2.0F, 3.0F },
                     NullableInts = new int?[] { null, 1, 2, 3 },
-                    NullableLongs = new long?[] { null, 1L, 2L, 3L }
+                    NullableLongs = new long?[] { null, 1L, 2L, 3L },
+                    EmptyDecimals = [],
+                    EmptyNullableDecimals = []
                 }
             ];
         }
diff --git a/tests/MongoDB.Driver.Tests/Linq/Linq3ImplementationWithLinq2Tests/IntegrationTestBase.cs b/tests/MongoDB.Driver.Tests/Linq/Linq3ImplementationWithLinq2Tests/IntegrationTestBase.cs
@@ -253,7 +253,11 @@ private void InsertSecond()
                 O = new List<long> { 100, 200, 300 },
                 P = 1.1,
                 U = -1.234565723762724332233489m,
-                Z = 10
+                Z = 10,
+                NullableW = 8,
+                NullableX = 9,
+                NullableY = 10,
+                NullableZ = 11
             };
             __collection.InsertOne(root);
         }
@@ -333,6 +337,14 @@ public class Root : IRoot
             public int Y { get; set; }
 
             public decimal Z { get; set; }
+
+            public double? NullableW { get; set; }
+
+            public long? NullableX { get; set; }
+
+            public int? NullableY { get; set; }
+
+            public decimal? NullableZ { get; set; }
         }
 
         public class RootDescended : Root
diff --git a/tests/MongoDB.Driver.Tests/Linq/Linq3ImplementationWithLinq2Tests/MongoQueryableTests.cs b/tests/MongoDB.Driver.Tests/Linq/Linq3ImplementationWithLinq2Tests/MongoQueryableTests.cs
@@ -135,6 +135,106 @@ public async Task AverageAsync_with_selector()
             result.Should().Be(61);
         }
 
+        [Fact]
+        public void Average_on_empty_set()
+        {
+            Action action = () => CreateQuery().Where(x => x.A == "__dummy__").Select(x => x.W).Average();
+
+            action.ShouldThrow<InvalidOperationException>().WithMessage("Sequence contains no elements");
+        }
+
+        [Fact]
+        public void Average_on_empty_set_with_selector()
+        {
+            Action action = () => CreateQuery().Where(x => x.A == "__dummy__").Average(x => x.X);
+
+            action.ShouldThrow<InvalidOperationException>().WithMessage("Sequence contains no elements");
+        }
+
+        [Fact]
+        public void AverageAsync_on_empty_set()
+        {
+            var subject = CreateQuery().Where(x => x.A == "__dummy__").Select(x => x.Y).AverageAsync();
+
+            subject.Awaiting(async q => await q)
+                .ShouldThrow<InvalidOperationException>()
+                .WithMessage("Sequence contains no elements");
+        }
+
+        [Fact]
+        public void AverageAsync_on_empty_set_with_selector()
+        {
+            var subject = CreateQuery().Where(x => x.A == "__dummy__").AverageAsync(x => x.Z);
+
+            subject.Awaiting(async q => await q)
+                .ShouldThrow<InvalidOperationException>()
+                .WithMessage("Sequence contains no elements");
+        }
+
+        [Fact]
+        public void Average_on_nullable_empty_set()
+        {
+            var result = CreateQuery().Where(x => x.A == "__dummy__").Select(x => x.NullableW).Average();
+
+            result.Should().Be(null);
+        }
+
+        [Fact]
+        public void Average_on_nullable_empty_set_with_selector()
+        {
+            var result = CreateQuery().Where(x => x.A == "__dummy__").Average(x => x.NullableX);
+
+            result.Should().Be(null);
+        }
+
+        [Fact]
+        public async Task AverageAsync_on_nullable_empty_set()
+        {
+            var result = await CreateQuery().Where(x => x.A == "__dummy__").Select(x => x.NullableY).AverageAsync();
+
+            result.Should().Be(null);
+        }
+
+        [Fact]
+        public async Task AverageAsync_on_nullable_empty_set_with_selector()
+        {
+            var result = await CreateQuery().Where(x => x.A == "__dummy__").AverageAsync(x => x.NullableZ);
+
+            result.Should().Be(null);
+        }
+
+        [Fact]
+        public void Average_on_empty_set_cast_to_nullable()
+        {
+            var result = CreateQuery().Where(x => x.A == "__dummy__").Select(x => (double?)x.W).Average();
+
+            result.Should().Be(null);
+        }
+
+        [Fact]
+        public void Average_on_empty_set_cast_to_nullable_with_selector()
+        {
+            var result = CreateQuery().Where(x => x.A == "__dummy__").Average(x => (long?)x.X);
+
+            result.Should().Be(null);
+        }
+
+        [Fact]
+        public async Task AverageAsync_on_empty_set_cast_to_nullable()
+        {
+            var result = await CreateQuery().Where(x => x.A == "__dummy__").Select(x => (int?)x.Y).AverageAsync();
+
+            result.Should().Be(null);
+        }
+
+        [Fact]
+        public async Task AverageAsync_on_empty_set_cast_to_nullable_with_selector()
+        {
+            var result = await CreateQuery().Where(x => x.A == "__dummy__").AverageAsync(x => (decimal?)x.Z);
+
+            result.Should().Be(null);
+        }
+
         [Fact]
         public void GroupBy_combined_with_a_previous_embedded_pipeline()
         {
