CSHARP-5552: Add support for $convert in LINQ

src/MongoDB.Bson/Serialization/Serializers/ByteSerializer.cs

@@ -23,6 +23,16 @@ namespace MongoDB.Bson.Serialization.Serializers
     /// </summary>
     public sealed class ByteSerializer : StructSerializerBase<byte>, IRepresentationConfigurable<ByteSerializer>
     {
+        #region static
+        private static readonly ByteSerializer __instance = new();
+
+        // public static properties
+        /// <summary>
+        /// Gets a cached instance of a default ByteSerializer.
+        /// </summary>
+        public static ByteSerializer Instance => __instance;
+        #endregion
+
         // private fields
         private readonly BsonType _representation;
 

src/MongoDB.Bson/Serialization/Serializers/Int16Serializer.cs

@@ -24,6 +24,15 @@ namespace MongoDB.Bson.Serialization.Serializers
     /// </summary>
     public sealed class Int16Serializer : StructSerializerBase<short>, IRepresentationConfigurable<Int16Serializer>, IRepresentationConverterConfigurable<Int16Serializer>
     {
+        #region static
+        private static readonly Int16Serializer __instance = new();
+
+        /// <summary>
+        /// Gets a cached instance of an Int16Serializer;
+        /// </summary>
+        public static Int16Serializer Instance => __instance;
+        #endregion
+
         // private fields
         private readonly BsonType _representation;
         private readonly RepresentationConverter _converter;

src/MongoDB.Bson/Serialization/Serializers/SByteSerializer.cs

@@ -24,6 +24,15 @@ namespace MongoDB.Bson.Serialization.Serializers
     [CLSCompliant(false)]
     public sealed class SByteSerializer : StructSerializerBase<sbyte>, IRepresentationConfigurable<SByteSerializer>
     {
+        #region static
+        private static readonly SByteSerializer __instance = new();
+
+        /// <summary>
+        /// Gets a cached instance of an SByteSerializer;
+        /// </summary>
+        public static SByteSerializer Instance => __instance;
+        #endregion
+
         // private fields
         private readonly BsonType _representation;
 

src/MongoDB.Bson/Serialization/Serializers/UInt16Serializer.cs

@@ -25,6 +25,15 @@ namespace MongoDB.Bson.Serialization.Serializers
     [CLSCompliant(false)]
     public sealed class UInt16Serializer : StructSerializerBase<ushort>, IRepresentationConfigurable<UInt16Serializer>, IRepresentationConverterConfigurable<UInt16Serializer>
     {
+        #region static
+        private static readonly UInt16Serializer __instance = new();
+
+        /// <summary>
+        /// Gets a cached instance of an UInt16Serializer;
+        /// </summary>
+        public static UInt16Serializer Instance => __instance;
+        #endregion
+
         // private fields
         private readonly BsonType _representation;
         private readonly RepresentationConverter _converter;

src/MongoDB.Bson/Serialization/Serializers/UInt64Serializer.cs

@@ -25,6 +25,15 @@ namespace MongoDB.Bson.Serialization.Serializers
     [CLSCompliant(false)]
     public sealed class UInt64Serializer : StructSerializerBase<ulong>, IRepresentationConfigurable<UInt64Serializer>, IRepresentationConverterConfigurable<UInt64Serializer>
     {
+        #region static
+        private static readonly UInt64Serializer __instance = new();
+
+        /// <summary>
+        /// Gets a cached instance of an UInt64Serializer;
+        /// </summary>
+        public static UInt64Serializer Instance => __instance;
+        #endregion
+
         // private fields
         private readonly BsonType _representation;
         private readonly RepresentationConverter _converter;

src/MongoDB.Driver/ConvertOptions.cs

@@ -0,0 +1,139 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Linq.Linq3Implementation.Serializers;
+
+namespace MongoDB.Driver
+{
+    /// <summary>
+    /// Represents the options parameter for <see cref="Mql.Convert{TFrom, TTo}(TFrom, ConvertOptions{TTo})"/>.
+    /// </summary>
+    public abstract class ConvertOptions
+    {
+        private ByteOrder? _byteOrder;
+        private string _format;
+        private BsonBinarySubType? _subType;
+
+        /// <summary>
+        /// The byteOrder parameter.
+        /// </summary>
+        public ByteOrder? ByteOrder
+        {
+            get => _byteOrder;
+            set => _byteOrder = value;
+        }
+
+        /// <summary>
+        /// The format parameter.
+        /// </summary>
+        public string Format
+        {
+            get => _format;
+            set => _format = value;
+        }
+
+        /// <summary>
+        /// The subType parameter.
+        /// </summary>
+        public BsonBinarySubType? SubType
+        {
+            get => _subType;
+            set => _subType = value;
+        }
+
+        internal abstract bool OnErrorWasSet(out object onError);
+
+        internal abstract bool OnNullWasSet(out object onError);
+    }
+
+    /// <summary>
+    /// Represents the options parameter for <see cref="Mql.Convert{TFrom, TTo}(TFrom, ConvertOptions{TTo})"/>.
+    /// This class allows to set 'onError' and 'onNull'.
+    /// </summary>
+    /// <typeparam name="TTo"> The type of 'onError' and 'onNull'.</typeparam>
+    public class ConvertOptions<TTo> : ConvertOptions
+    {
+        private TTo _onError;
+        private bool _onErrorWasSet;
+        private TTo _onNull;
+        private bool _onNullWasSet;
+        private readonly IBsonSerializer _serializer;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConvertOptions{TTo}"/> class.
+        /// </summary>
+        public ConvertOptions()
+        {
+            _serializer = StandardSerializers.TryGetSerializer(typeof(TTo), out var serializer)
+                ? serializer
+                : BsonSerializer.LookupSerializer(typeof(TTo));
+        }
+
+        /// <summary>
+        /// The onError parameter.
+        /// </summary>
+        public TTo OnError
+        {
+            get => _onError;
+            set
+            {
+                _onError = value;
+                _onErrorWasSet = true;
+            }
+        }
+
+        /// <summary>
+        /// The onNull parameter.
+        /// </summary>
+        public TTo OnNull
+        {
+            get => _onNull;
+            set
+            {
+                _onNull = value;
+                _onNullWasSet = true;
+            }
+        }
+
+        internal override bool OnErrorWasSet(out object onError)
+        {
+            onError = _onError;
+            return _onErrorWasSet;
+        }
+
+        internal override bool OnNullWasSet(out object onNull)
+        {
+            onNull = _onNull;
+            return _onNullWasSet;
+        }
+    }
+
+    /// <summary>
+    /// Represents the byte order of binary data when converting to/from numerical types using <see cref="Mql.Convert{TFrom, TTo}(TFrom, ConvertOptions{TTo})"/>.
+    /// </summary>
+    public enum ByteOrder
+    {
+        /// <summary>
+        /// Big endian order.
+        /// </summary>
+        BigEndian,
+        /// <summary>
+        /// Little endian order.
+        /// </summary>
+        LittleEndian,
+    }
+}

src/MongoDB.Driver/Core/Misc/Feature.cs

@@ -44,6 +44,8 @@ public class Feature
         private static readonly Feature __clientBulkWrite = new Feature("ClientBulkWrite", WireVersion.Server80);
         private static readonly Feature __clientSideEncryption = new Feature("ClientSideEncryption", WireVersion.Server42);
         private static readonly Feature __clusteredIndexes = new Feature("ClusteredIndexes", WireVersion.Server53);
+        private static readonly Feature __convertOperatorBinDataToFromNumeric = new Feature("ConvertOperatorBinDataToFromNumeric", WireVersion.Server81);
+        private static readonly Feature __convertOperatorBinDataToFromString= new Feature("ConvertOperatorBinDataToFromString", WireVersion.Server80);
         private static readonly Feature __createIndexCommitQuorum = new Feature("CreateIndexCommitQuorum", WireVersion.Server44);
         private static readonly Feature __createIndexesUsingInsertOperations = new Feature("CreateIndexesUsingInsertOperations", WireVersion.Zero, WireVersion.Server42);
         private static readonly Feature __csfleRangeAlgorithm = new Feature("CsfleRangeAlgorithm", WireVersion.Server62);
@@ -193,6 +195,16 @@ public class Feature
         /// </summary>
         public static Feature ClusteredIndexes => __clusteredIndexes;
 
+        /// <summary>
+        /// Gets the conversion of binary data to/from numeric types feature.
+        /// </summary>
+        public static Feature ConvertOperatorBinDataToFromNumeric => __convertOperatorBinDataToFromNumeric;
+
+        /// <summary>
+        /// Gets the conversion of binary data to/from string feature.
+        /// </summary>
+        public static Feature ConvertOperatorBinDataToFromString => __convertOperatorBinDataToFromString;
+
         /// <summary>
         /// Gets the create index commit quorum feature.
         /// </summary>

src/MongoDB.Driver/Linq/Linq3Implementation/Ast/AstEnumExtensions.cs

@@ -0,0 +1,61 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using MongoDB.Bson;
+
+namespace MongoDB.Driver.Linq.Linq3Implementation.Ast
+{
+    internal static class AstEnumExtensions
+    {
+        public static string Render(this BsonType type)
+        {
+            return type switch
+            {
+                BsonType.Array => "array",
+                BsonType.Binary => "binData",
+                BsonType.Boolean => "bool",
+                BsonType.DateTime => "date",
+                BsonType.Decimal128 => "decimal",
+                BsonType.Document => "object",
+                BsonType.Double => "double",
+                BsonType.Int32 => "int",
+                BsonType.Int64 => "long",
+                BsonType.JavaScript => "javascript",
+                BsonType.JavaScriptWithScope => "javascriptWithScope",
+                BsonType.MaxKey => "maxKey",
+                BsonType.MinKey => "minKey",
+                BsonType.Null => "null",
+                BsonType.ObjectId => "objectId",
+                BsonType.RegularExpression => "regex",
+                BsonType.String => "string",
+                BsonType.Symbol => "symbol",
+                BsonType.Timestamp => "timestamp",
+                BsonType.Undefined => "undefined",
+                _ => throw new ArgumentException($"Unexpected BSON type: {type}.", nameof(type))
+            };
+        }
+
+        public static string Render(this ByteOrder byteOrder)
+        {
+            return byteOrder switch
+            {
+                ByteOrder.BigEndian => "big",
+                ByteOrder.LittleEndian => "little",
+                _ => throw new ArgumentException($"Unexpected {nameof(ByteOrder)}: {byteOrder}.", nameof(byteOrder))
+            };
+        }
+    }
+}

src/MongoDB.Driver/Linq/Linq3Implementation/Ast/Expressions/AstConvertExpression.cs

@@ -21,27 +21,39 @@ namespace MongoDB.Driver.Linq.Linq3Implementation.Ast.Expressions
 {
     internal sealed class AstConvertExpression : AstExpression
     {
+        private readonly ByteOrder? _byteOrder;
+        private readonly string _format;
         private readonly AstExpression _input;
         private readonly AstExpression _onError;
         private readonly AstExpression _onNull;
+        private readonly BsonBinarySubType? _subType;
         private readonly AstExpression _to;
 
         public AstConvertExpression(
             AstExpression input,
             AstExpression to,
+            BsonBinarySubType? subType = null,
+            ByteOrder? byteOrder = null,
+            string format = null,
             AstExpression onError = null,
             AstExpression onNull = null)
         {
             _input = Ensure.IsNotNull(input, nameof(input));
             _to = Ensure.IsNotNull(to, nameof(to));
+            _subType = subType;
+            _byteOrder = byteOrder;
+            _format = format;
             _onError = onError;
             _onNull = onNull;
         }
 
+        public ByteOrder? ByteOrder => _byteOrder;
+        public string Format => _format;
         public AstExpression Input => _input;
         public override AstNodeType NodeType => AstNodeType.ConvertExpression;
         public AstExpression OnError => _onError;
         public AstExpression OnNull => _onNull;
+        public BsonBinarySubType? SubType => _subType;
         public AstExpression To => _to;
 
         public override AstNode Accept(AstNodeVisitor visitor)
@@ -56,9 +68,18 @@ public override BsonValue Render()
                 { "$convert", new BsonDocument
                     {
                         { "input", _input.Render() },
-                        { "to", _to.Render() },
+                        { "to", _to.Render(), _subType == null },
+                        { "to", () => new BsonDocument
+                            {
+                                { "type", _to.Render() },
+                                { "subtype", (int)_subType!.Value},
+                            },
+                            _subType != null
+                        },
                         { "onError", () => _onError.Render(), _onError != null },
-                        { "onNull", () => _onNull.Render(), _onNull != null }
+                        { "onNull", () => _onNull.Render(), _onNull != null },
+                        { "format", () => _format, _format != null },
+                        { "byteOrder", () => _byteOrder!.Value.Render(), _byteOrder != null }
                     }
                 }
             };
@@ -75,7 +96,7 @@ public AstConvertExpression Update(
                 return this;
             }
 
-            return new AstConvertExpression(input, to, onError, onNull);
+            return new AstConvertExpression(input, to, _subType, _byteOrder, _format, onError, onNull);
         }
     }
 }