Query: Added remaining Cosmos Type checking functions to CosmosLinqExtensions

Microsoft.Azure.Cosmos/src/Linq/BuiltinFunctions/TypeCheckFunctions.cs

@@ -19,7 +19,25 @@ static TypeCheckFunctions()
             TypeCheckFunctionsDefinitions = new Dictionary<string, BuiltinFunctionVisitor>
             {
                 {
-                    "IsDefined",
+                    nameof(CosmosLinqExtensions.IsArray),
+                    new SqlBuiltinFunctionVisitor("IS_ARRAY",
+                    true,
+                    new List<Type[]>()
+                    {
+                        new Type[]{typeof(object)},
+                    })
+                },
+                {
+                    nameof(CosmosLinqExtensions.IsBool),
+                    new SqlBuiltinFunctionVisitor("IS_BOOL",
+                    true,
+                    new List<Type[]>()
+                    {
+                        new Type[]{typeof(object)},
+                    })
+                },
+                {
+                    nameof(CosmosLinqExtensions.IsDefined),
                     new SqlBuiltinFunctionVisitor("IS_DEFINED",
                     true,
                     new List<Type[]>()
@@ -28,7 +46,7 @@ static TypeCheckFunctions()
                     })
                 },
                 {
-                    "IsNull",
+                    nameof(CosmosLinqExtensions.IsNull),
                     new SqlBuiltinFunctionVisitor("IS_NULL",
                     true,
                     new List<Type[]>()
@@ -37,13 +55,40 @@ static TypeCheckFunctions()
                     })
                 },
                 {
-                    "IsPrimitive",
+                    nameof(CosmosLinqExtensions.IsNumber),
+                    new SqlBuiltinFunctionVisitor("IS_NUMBER",
+                    true,
+                    new List<Type[]>()
+                    {
+                        new Type[]{typeof(object)},
+                    })
+                },
+                {
+                    nameof(CosmosLinqExtensions.IsObject),
+                    new SqlBuiltinFunctionVisitor("IS_OBJECT",
+                    true,
+                    new List<Type[]>()
+                    {
+                        new Type[]{typeof(object)},
+                    })
+                },
+                {
+                    nameof(CosmosLinqExtensions.IsPrimitive),
                     new SqlBuiltinFunctionVisitor("IS_PRIMITIVE",
                     true,
                     new List<Type[]>()
                     {
                         new Type[]{typeof(object)},
                     })
+                },
+                {
+                    nameof(CosmosLinqExtensions.IsString),
+                    new SqlBuiltinFunctionVisitor("IS_STRING",
+                    true,
+                    new List<Type[]>()
+                    {
+                        new Type[]{typeof(object)},
+                    })
                 }
             };
         }

Microsoft.Azure.Cosmos/src/Linq/CosmosLinqExtensions.cs

@@ -20,6 +20,40 @@ namespace Microsoft.Azure.Cosmos.Linq
     /// </summary>
     public static class CosmosLinqExtensions
     {
+        /// <summary>
+        /// Returns a Boolean value indicating if the type of the specified expression is an array.
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns>Returns true if the type of the specified expression is an array; otherwise, false.</returns>
+        /// <example>
+        /// <code>
+        /// <![CDATA[
+        /// var isArrayQuery = documents.Where(document => document.Names.IsArray());
+        /// ]]>
+        /// </code>
+        /// </example>
+        public static bool IsArray(this object obj)
+        {
+            throw new NotImplementedException(ClientResources.TypeCheckExtensionFunctionsNotImplemented);
+        }
+
+        /// <summary>
+        /// Returns a Boolean value indicating if the type of the specified expression is a boolean.
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns>Returns true if the type of the specified expression is a boolean; otherwise, false.</returns>
+        /// <example>
+        /// <code>
+        /// <![CDATA[
+        /// var isBoolQuery = documents.Where(document => document.IsRegistered.IsBool());
+        /// ]]>
+        /// </code>
+        /// </example>
+        public static bool IsBool(this object obj)
+        {
+            throw new NotImplementedException(ClientResources.TypeCheckExtensionFunctionsNotImplemented);
+        }
+
         /// <summary>
         /// Determines if a certain property is defined or not.
         /// This method is to be used in LINQ expressions only and will be evaluated on server.
@@ -52,12 +86,46 @@ public static bool IsDefined(this object obj)
         /// var isNullQuery = documents.Where(document => document.Name.IsNull());
         /// ]]>
         /// </code>
-        /// </example>s>
+        /// </example>
         public static bool IsNull(this object obj)
         {
             throw new NotImplementedException(ClientResources.TypeCheckExtensionFunctionsNotImplemented);
         }
 
+        /// <summary>
+        /// Returns a Boolean value indicating if the type of the specified expression is a number.
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns>Returns true if the type of the specified expression is a number; otherwise, false.</returns>
+        /// <example>
+        /// <code>
+        /// <![CDATA[
+        /// var isNumberQuery = documents.Where(document => document.Age.IsNumber());
+        /// ]]>
+        /// </code>
+        /// </example>
+        public static bool IsNumber(this object obj)
+        {
+            throw new NotImplementedException(ClientResources.TypeCheckExtensionFunctionsNotImplemented);
+        }
+
+        /// <summary>
+        /// Returns a Boolean value indicating if the type of the specified expression is an object.
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns>Returns true if the type of the specified expression is an object; otherwise, false.</returns>
+        /// <example>
+        /// <code>
+        /// <![CDATA[
+        /// var isObjectQuery = documents.Where(document => document.Address.IsObject());
+        /// ]]>
+        /// </code>
+        /// </example>
+        public static bool IsObject(this object obj)
+        {
+            throw new NotImplementedException(ClientResources.TypeCheckExtensionFunctionsNotImplemented);
+        }
+
         /// <summary>
         /// Determines if a certain property is of primitive JSON type.
         /// This method is to be used in LINQ expressions only and will be evaluated on server.
@@ -74,12 +142,29 @@ public static bool IsNull(this object obj)
         /// var isPrimitiveQuery = documents.Where(document => document.Name.IsPrimitive());
         /// ]]>
         /// </code>
-        /// </example>s>
+        /// </example>
         public static bool IsPrimitive(this object obj)
         {
             throw new NotImplementedException(ClientResources.TypeCheckExtensionFunctionsNotImplemented);
         }
 
+        /// <summary>
+        /// Returns a Boolean value indicating if the type of the specified expression is a string.
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns>Returns true if the type of the specified expression is a string; otherwise, false.</returns>
+        /// <example>
+        /// <code>
+        /// <![CDATA[
+        /// var isStringQuery = documents.Where(document => document.Name.IsString());
+        /// ]]>
+        /// </code>
+        /// </example>
+        public static bool IsString(this object obj)
+        {
+            throw new NotImplementedException(ClientResources.TypeCheckExtensionFunctionsNotImplemented);
+        }
+
         /// <summary>
         /// This method generate query definition from LINQ query.
         /// </summary>
@@ -98,6 +183,7 @@ public static bool IsPrimitive(this object obj)
         /// ]]>
         /// </code>
         /// </example>
+
 #if PREVIEW
         public
 #else

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.EmulatorTests/LinqTranslationBaselineTests.cs

@@ -116,6 +116,7 @@ internal class DataObject : LinqTestObject
             public int? NullableField;
 #pragma warning disable CS0649 // Field is never assigned to, and will always have its default value false
             public bool BooleanField;
+            public SimpleObject ObjectField = new SimpleObject();
             public Guid GuidField;
 #pragma warning restore // Field is never assigned to, and will always have its default value false
 
@@ -155,6 +156,11 @@ internal class DataObject : LinqTestObject
             public string Pk;
         }
 
+        internal class SimpleObject
+        {
+            public string Field { get; set; }
+        }
+
         class DateJsonConverter : IsoDateTimeConverter
         {
             public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
@@ -266,12 +272,22 @@ public void TestTypeCheckFunctions()
 
             List<LinqTestInput> inputs = new List<LinqTestInput>
             {
+                new LinqTestInput("IsArray array", b => getQuery(b).Where(doc => doc.ArrayField.IsArray())),
+                new LinqTestInput("IsArray string", b => getQuery(b).Where(doc => doc.StringField.IsArray())),
+                new LinqTestInput("IsBool bool", b => getQuery(b).Where(doc => doc.BooleanField.IsBool())),
+                new LinqTestInput("IsBool string", b => getQuery(b).Where(doc => doc.StringField.IsBool())),
                 new LinqTestInput("IsDefined array", b => getQuery(b).Select(doc => doc.ArrayField.IsDefined())),
                 new LinqTestInput("IsDefined string", b => getQuery(b).Where(doc => doc.StringField.IsDefined())),
                 new LinqTestInput("IsNull array", b => getQuery(b).Select(doc => doc.ArrayField.IsNull())),
                 new LinqTestInput("IsNull string", b => getQuery(b).Where(doc => doc.StringField.IsNull())),
+                new LinqTestInput("IsNumber number", b => getQuery(b).Select(doc => doc.NumericField.IsNumber())),
+                new LinqTestInput("IsNumber string", b => getQuery(b).Where(doc => doc.StringField.IsNumber())),
+                new LinqTestInput("IsObject object", b => getQuery(b).Select(doc => doc.ObjectField.IsObject())),
+                new LinqTestInput("IsObject string", b => getQuery(b).Where(doc => doc.StringField.IsObject())),
                 new LinqTestInput("IsPrimitive array", b => getQuery(b).Select(doc => doc.ArrayField.IsPrimitive())),
-                new LinqTestInput("IsPrimitive string", b => getQuery(b).Where(doc => doc.StringField.IsPrimitive()))
+                new LinqTestInput("IsPrimitive string", b => getQuery(b).Where(doc => doc.StringField.IsPrimitive())),
+                new LinqTestInput("IsString string", b => getQuery(b).Where(doc => doc.StringField.IsString())),
+                new LinqTestInput("IsString number", b => getQuery(b).Select(doc => doc.NumericField.IsString())),
             };
             this.ExecuteTestSuite(inputs);
         }