CSHARP-4927: Add support for Atlas Search $in operator to builder (#1249)

Author: BorisDog

src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs

@@ -222,6 +222,48 @@ private protected override BsonDocument RenderArguments(SearchDefinitionRenderCo
             new(_area.Render());
     }
 
+    internal sealed class InSearchDefinition<TDocument, TField> : OperatorSearchDefinition<TDocument>
+    {
+        private readonly BsonArray _values;
+
+        public InSearchDefinition(
+           SearchPathDefinition<TDocument> path,
+           IEnumerable<TField> values,
+           SearchScoreDefinition<TDocument> score)
+                : base(OperatorType.In, path, score)
+        {
+            Ensure.IsNotNullOrEmpty(values, nameof(values));
+            var array = new BsonArray(values.Select(ToBsonValue));
+
+            var bsonType = array[0].GetType();
+            _values = Ensure.That(array, arr => arr.All(v => v.GetType() == bsonType), nameof(values), "All values must be of the same type.");
+        }
+
+        private protected override BsonDocument RenderArguments(SearchDefinitionRenderContext<TDocument> renderContext) =>
+            new("value", _values);
+
+        private static BsonValue ToBsonValue(TField value) =>
+            value switch
+            {
+                bool v => (BsonBoolean)v,
+                sbyte v => (BsonInt32)v,
+                byte v => (BsonInt32)v,
+                short v => (BsonInt32)v,
+                ushort v => (BsonInt32)v,
+                int v => (BsonInt32)v,
+                uint v => (BsonInt64)v,
+                long v => (BsonInt64)v,
+                float v => (BsonDouble)v,
+                double v => (BsonDouble)v,
+                decimal v => (BsonDecimal128)v,
+                DateTime v => (BsonDateTime)v,
+                DateTimeOffset v => (BsonDateTime)v.UtcDateTime,
+                string v => (BsonString)v,
+                ObjectId v => (BsonObjectId)v,
+                _ => throw new InvalidCastException()
+            };
+    }
+
     internal sealed class MoreLikeThisSearchDefinition<TDocument, TLike> : OperatorSearchDefinition<TDocument>
     {
         private readonly TLike[] _like;

src/MongoDB.Driver/Search/SearchDefinition.cs

@@ -116,6 +116,7 @@ private protected enum OperatorType
             Facet,
             GeoShape,
             GeoWithin,
+            In,
             MoreLikeThis,
             Near,
             Phrase,

src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs

@@ -298,6 +298,34 @@ public SearchDefinition<TDocument> GeoWithin<TCoordinates>(
             where TCoordinates : GeoJsonCoordinates =>
                 new GeoWithinSearchDefinition<TDocument, TCoordinates>(path, area, score);
 
+        /// <summary>
+        /// Creates a search definition that queries for documents where the value of the field equals to any of specified values.
+        /// </summary>
+        /// <typeparam name="TField">The type of the field. Valid types are: boolean, ObjectId, number, date, string.</typeparam>
+        /// <param name="path">The indexed field or fields to search.</param>
+        /// <param name="values">Values to compare the field with.</param>
+        /// <param name="score">The score modifier.</param>
+        /// <returns>An In search definition.</returns>
+        public SearchDefinition<TDocument> In<TField>(
+            SearchPathDefinition<TDocument> path,
+            IEnumerable<TField> values,
+            SearchScoreDefinition<TDocument> score = null) =>
+                new InSearchDefinition<TDocument, TField>(path, values, score);
+
+        /// <summary>
+        /// Creates a search definition that queries for documents where the value of the field equals to any of specified values.
+        /// </summary>
+        /// <typeparam name="TField">The type of the field. Valid types are: boolean, ObjectId, number, date, string.</typeparam>
+        /// <param name="path">The indexed field or fields to search.</param>
+        /// <param name="values">Values to compare the field with.</param>
+        /// <param name="score">The score modifier.</param>
+        /// <returns>An In search definition.</returns>
+        public SearchDefinition<TDocument> In<TField>(
+            Expression<Func<TDocument, TField>> path,
+            IEnumerable<TField> values,
+            SearchScoreDefinition<TDocument> score = null) =>
+                In(new ExpressionFieldDefinition<TDocument>(path), values, score);
+
         /// <summary>
         /// Creates a search definition that returns documents similar to the input documents.
         /// </summary>

tests/MongoDB.Driver.Tests/Search/AtlasSearchTests.cs

@@ -222,6 +222,22 @@ public void GeoWithin(string geometryType)
             results.First().Name.Should().Be("Ribeira Charming Duplex");
         }
 
+        [Fact]
+        public void In()
+        {
+            var results = GetSynonymTestCollection()
+                .Aggregate()
+                .Search(
+                    Builders<Movie>.Search.In(x => x.Runtime, new[] { 31, 231 }),
+                    new() { Sort = Builders<Movie>.Sort.Descending(x => x.Runtime)})
+                .Limit(10)
+                .ToList();
+
+            results.Count.Should().Be(2);
+            results[0].Runtime.Should().Be(231);
+            results[1].Runtime.Should().Be(31);
+        }
+
         [Fact]
         public void MoreLikeThis()
         {
@@ -437,14 +453,12 @@ public void Should()
         [Fact]
         public void Sort()
         {
-            var results = GetTestCollection().Aggregate()
-                .Search(
-                    Builders.Search.Text(x => x.Body, "liberty"),
-                    new() { Sort = Builders.Sort.Descending(x => x.Title) })
-                .Project<HistoricalDocument>(Builders.Projection.Include(x => x.Title))
-                .Limit(1)
-                .ToList();
-            results.Should().ContainSingle().Which.Title.Should().Be("US Constitution");
+            var result = SearchSingle(
+                Builders.Search.Text(x => x.Body, "liberty"),
+                Builders.Projection.Include(x => x.Title),
+                Builders.Sort.Descending(x => x.Title));
+
+            result.Title.Should().Be("US Constitution");
         }
 
         [Fact]
@@ -632,6 +646,9 @@ public class Movie
             [BsonElement("title")]
             public string Title { get; set; }
 
+            [BsonElement("runtime")]
+            public int Runtime { get; set; }
+
             [BsonElement("score")]
             public double Score { get; set; }
         }

tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs

@@ -475,6 +475,118 @@ public void GeoWithin_typed()
                 "{ geoWithin: { circle: { center: { type: 'Point', coordinates: [-161.323242, 22.512557] }, radius: 7.5 }, path: 'location' } }");
         }
 
+        [Theory]
+        [MemberData(nameof(InTestData))]
+        public void In<T>(T[] fieldValues, string[] fieldsRendered)
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            AssertRendered(
+                subject.In("x", fieldValues),
+                $"{{ in: {{ path: 'x', value: [{string.Join(",", fieldsRendered)}] }} }}");
+        }
+
+        public static readonly object[][] InTestData =
+        {
+             new object[] { new bool[] { true, false }, new[] { "true", "false" } },
+             new object[] { new byte[] { 1, 2 }, new[] { "1", "2" } },
+             new object[] { new sbyte[] { 1, 2 }, new[] { "1", "2" } },
+             new object[] { new short[] { 1, 2 }, new[] { "1", "2" } },
+             new object[] { new ushort[] { 1, 2 }, new[] { "1", "2" } },
+             new object[] { new int[] { 1, 2 }, new[] { "1", "2" } },
+             new object[] { new uint[] { 1, 2 }, new[] { "1", "2" } },
+             new object[] { new long[] { long.MaxValue, long.MinValue }, new[] { "NumberLong(\"9223372036854775807\")", "NumberLong(\"-9223372036854775808\")" } },
+             new object[] { new float[] { 1.5f, 2.5f }, new[] { "1.5", "2.5" } },
+             new object[] { new double[] { 1.5, 2.5 }, new[] { "1.5", "2.5" } },
+             new object[] { new decimal[] { 1.5m, 2.5m }, new[] { "NumberDecimal(\"1.5\")", "NumberDecimal(\"2.5\")" } },
+             new object[] { new[] { "str1", "str2" }, new[] { "'str1'", "'str2'" } },
+             new object[] { new[] { DateTime.MinValue, DateTime.MaxValue }, new[] { "ISODate(\"0001-01-01T00:00:00Z\")", "ISODate(\"9999-12-31T23:59:59.999Z\")" } },
+             new object[] { new[] { DateTimeOffset.MinValue, DateTimeOffset.MaxValue }, new[] { "ISODate(\"0001-01-01T00:00:00Z\")", "ISODate(\"9999-12-31T23:59:59.999Z\")" } },
+             new object[] { new[] { ObjectId.Empty, ObjectId.Parse("4d0ce088e447ad08b4721a37") }, new[] { "{ $oid: '000000000000000000000000' }", "{ $oid: '4d0ce088e447ad08b4721a37' }" } },
+             new object[] { new object[] { (byte)1, (short)2, (int)3 }, new[] { "1", "2", "3" } }
+        };
+
+        [Theory]
+        [MemberData(nameof(InTypedTestData))]
+        public void In_typed<T>(
+            T[] fieldValues,
+            string[] fieldValuesRendered,
+            Expression<Func<Person, T>> fieldExpression,
+            string fieldNameRendered)
+        {
+            var subject = CreateSubject<Person>();
+            var fieldValuesArray = $"[{string.Join(",", fieldValuesRendered)}]";
+
+            AssertRendered(
+                subject.In("x", fieldValues),
+                $"{{ in: {{ path: 'x', value: {fieldValuesArray} }} }}");
+
+            AssertRendered(
+                subject.In(fieldExpression, fieldValues),
+                $"{{ in: {{path: '{fieldNameRendered}', value: {fieldValuesArray} }} }}");
+        }
+
+        public static readonly object[][] InTypedTestData =
+       {
+             new object[] { new bool[] { true, false }, new[] { "true", "false" }, Exp(p => p.Retired), "ret" },
+             new object[] { new byte[] { 1, 2 }, new[] { "1", "2" }, Exp(p => p.UInt8), nameof(Person.UInt8) },
+             new object[] { new sbyte[] { 1, 2 }, new[] { "1", "2" }, Exp(p => p.Int8), nameof(Person.Int8) },
+             new object[] { new short[] { 1, 2 }, new[] { "1", "2" }, Exp(p => p.Int16), nameof(Person.Int16) },
+             new object[] { new ushort[] { 1, 2 }, new[] { "1", "2" }, Exp(p => p.UInt16), nameof(Person.UInt16) },
+             new object[] { new int[] { 1, 2 }, new[] { "1", "2" }, Exp(p => p.Int32), nameof(Person.Int32) },
+             new object[] { new uint[] { 1, 2 }, new[] { "1", "2" }, Exp(p => p.UInt32), nameof(Person.UInt32) },
+             new object[] { new long[] { long.MaxValue, long.MinValue }, new[] { "NumberLong(\"9223372036854775807\")", "NumberLong(\"-9223372036854775808\")" }, Exp(p => p.Int64), nameof(Person.Int64) },
+             new object[] { new float[] { 1.5f, 2.5f }, new[] { "1.5", "2.5" }, Exp(p => p.Float), nameof(Person.Float) },
+             new object[] { new double[] { 1.5, 2.5 }, new[] { "1.5", "2.5" }, Exp(p => p.Double), nameof(Person.Double) },
+             new object[] { new decimal[] { 1.5m, 2.5m }, new[] { "NumberDecimal(\"1.5\")", "NumberDecimal(\"2.5\")" }, Exp(p => p.Decimal), nameof(Person.Decimal) },
+             new object[] { new[] { "str1", "str2" }, new[] { "'str1'", "'str2'" }, Exp(p => p.FirstName), "fn" },
+             new object[] { new[] { DateTime.MinValue, DateTime.MaxValue }, new[] { "ISODate(\"0001-01-01T00:00:00Z\")", "ISODate(\"9999-12-31T23:59:59.999Z\")" }, Exp(p => p.Birthday), "dob" },
+             new object[] { new[] { DateTimeOffset.MinValue, DateTimeOffset.MaxValue }, new[] { "ISODate(\"0001-01-01T00:00:00Z\")", "ISODate(\"9999-12-31T23:59:59.999Z\")" }, Exp(p => p.DateTimeOffset), nameof(Person.DateTimeOffset)},
+             new object[] { new[] { ObjectId.Empty, ObjectId.Parse("4d0ce088e447ad08b4721a37") }, new[] { "{ $oid: '000000000000000000000000' }", "{ $oid: '4d0ce088e447ad08b4721a37' }" }, Exp(p => p.Id), "_id" },
+             new object[] { new object[] { (byte)1, (short)2, (int)3 }, new[] { "1", "2", "3" }, Exp(p => p.Object), nameof(Person.Object) }
+        };
+
+        [Theory]
+        [MemberData(nameof(InUnsupportedTypesTestData))]
+        public void In_should_throw_on_unsupported_types<T>(T value, Expression<Func<Person, T>> fieldExpression)
+        {
+            var subject = CreateSubject<BsonDocument>();
+            Record.Exception(() => subject.In("x", new[] { value } )).Should().BeOfType<InvalidCastException>();
+
+            var subjectTyped = CreateSubject<Person>();
+            Record.Exception(() => subjectTyped.In(fieldExpression, new[] { value })).Should().BeOfType<InvalidCastException>();
+        }
+
+        [Fact]
+        public void In_should_throw_when_values_are_invalid()
+        {
+            var subject = CreateSubject<BsonDocument>();
+            Record.Exception(() => subject.In("x", new int[] { })).Should().BeOfType<ArgumentException>();
+            Record.Exception(() => subject.In<int>("x", null)).Should().BeOfType<ArgumentNullException>();
+
+            var subjectTyped = CreateSubject<Person>();
+            Record.Exception(() => subjectTyped.In(p => p.Age, new int[] { })).Should().BeOfType<ArgumentException>();
+            Record.Exception(() => subjectTyped.In(p => p.Age, null)).Should().BeOfType<ArgumentNullException>();
+        }
+
+        public static object[][] InUnsupportedTypesTestData => new[]
+        {
+            new object[] { (ulong)1, Exp(p => p.UInt64) },
+            new object[] { TimeSpan.Zero, Exp(p => p.TimeSpan) },
+        };
+
+        [Fact]
+        public void In_should_throw_when_values_are_not_of_same_type()
+        {
+            var values = new object[] { 1.5, 1 };
+
+            var subject = CreateSubject<BsonDocument>();
+            Record.Exception(() => subject.In("x", values)).Should().BeOfType<ArgumentException>();
+
+            var subjectTyped = CreateSubject<Person>();
+            Record.Exception(() => subjectTyped.In(p => p.Object, values)).Should().BeOfType<ArgumentException>();
+        }
+
         [Fact]
         public void MoreLikeThis()
         {
@@ -1117,6 +1229,7 @@ public class Person : SimplePerson
             public ulong UInt64 { get; set; }
             public float Float { get; set; }
             public double Double { get; set; }
+            public decimal Decimal { get; set; }
 
             public DateTimeOffset DateTimeOffset { get; set; }
             public TimeSpan TimeSpan { get; set; }
@@ -1135,6 +1248,8 @@ public class Person : SimplePerson
 
             [BsonElement("ret")]
             public bool Retired { get; set; }
+
+            public object Object { get; set; }
         }
 
         public class Family