LINQ : Adds support for case-insensitive searches

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

@@ -67,7 +67,14 @@ protected override SqlScalarExpression VisitImplicit(MethodCallExpression method
                     SqlScalarExpression haystack = ExpressionToSql.VisitScalarExpression(methodCallExpression.Arguments[0], context);
                     SqlScalarExpression needle = ExpressionToSql.VisitScalarExpression(methodCallExpression.Arguments[1], context);
                     return SqlFunctionCallScalarExpression.CreateBuiltin("CONTAINS", haystack, needle);
+                }
 
+                if (methodCallExpression.Arguments.Count == 3)
+                {
+                    SqlScalarExpression haystack = ExpressionToSql.VisitScalarExpression(methodCallExpression.Arguments[0], context);
+                    SqlScalarExpression needle = ExpressionToSql.VisitScalarExpression(methodCallExpression.Arguments[1], context);
+                    SqlScalarExpression caseInsensitive = SqlStringWithComparisonVisitor.GetCaseInsensitiveExpression(methodCallExpression.Arguments[2]);
+                    return SqlFunctionCallScalarExpression.CreateBuiltin("CONTAINS", haystack, needle, caseInsensitive);
                 }
 
                 return null;
@@ -155,6 +162,65 @@ protected override SqlScalarExpression VisitImplicit(MethodCallExpression method
             }
         }
 
+        private class SqlStringWithComparisonVisitor : BuiltinFunctionVisitor
+        {
+            private static readonly HashSet<StringComparison> IgnoreCaseComparisons = new HashSet<StringComparison>(new[]
+            {
+                StringComparison.CurrentCultureIgnoreCase,
+                StringComparison.InvariantCultureIgnoreCase,
+                StringComparison.OrdinalIgnoreCase
+            });
+
+            public string SqlName { get; private set; }
+
+            public SqlStringWithComparisonVisitor(string sqlName)
+            {
+                this.SqlName = sqlName;
+            }
+
+            public static SqlScalarExpression GetCaseInsensitiveExpression(Expression expression)
+            {
+                ConstantExpression inputExpression = expression as ConstantExpression;
+                if (inputExpression?.Value is StringComparison comparisonValue)
+                {
+                    if (IgnoreCaseComparisons.Contains(comparisonValue))
+                    {
+                        SqlBooleanLiteral literal = SqlBooleanLiteral.Create(true);
+                        return SqlLiteralScalarExpression.Create(literal);
+                    }
+                }
+
+                return null;
+
+            }
+
+            protected override SqlScalarExpression VisitImplicit(MethodCallExpression methodCallExpression, TranslationContext context)
+            {
+                int argumentCount = methodCallExpression.Arguments.Count;
+                if (argumentCount == 0 || argumentCount > 2)
+                {
+                    return null;
+                }
+
+                List<SqlScalarExpression> arguments = new List<SqlScalarExpression>();
+
+                arguments.Add(ExpressionToSql.VisitNonSubqueryScalarExpression(methodCallExpression.Object, context));
+                arguments.Add(ExpressionToSql.VisitNonSubqueryScalarExpression(methodCallExpression.Arguments[0], context));
+
+                if (argumentCount > 1)
+                {
+                    arguments.Add(GetCaseInsensitiveExpression(methodCallExpression.Arguments[1]));
+                }
+
+                return SqlFunctionCallScalarExpression.CreateBuiltin(this.SqlName, arguments.ToArray());
+            }
+
+            protected override SqlScalarExpression VisitExplicit(MethodCallExpression methodCallExpression, TranslationContext context)
+            {
+                return null;
+            }
+        }
+
         private class StringVisitTrimEnd : SqlBuiltinFunctionVisitor
         {
             public StringVisitTrimEnd()
@@ -234,6 +300,15 @@ protected override SqlScalarExpression VisitImplicit(MethodCallExpression method
                     return SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Equal, left, right);
                 }
 
+                if (methodCallExpression.Arguments.Count == 2)
+                {
+                    SqlScalarExpression left = ExpressionToSql.VisitScalarExpression(methodCallExpression.Object, context);
+                    SqlScalarExpression right = ExpressionToSql.VisitScalarExpression(methodCallExpression.Arguments[0], context);
+                    SqlScalarExpression caseInsensitive = SqlStringWithComparisonVisitor.GetCaseInsensitiveExpression(methodCallExpression.Arguments[1]);
+
+                    return SqlFunctionCallScalarExpression.CreateBuiltin("STRINGEQUALS", left, right, caseInsensitive);
+                }
+
                 return null;
             }
 
@@ -257,12 +332,7 @@ static StringBuiltinFunctions()
                 },
                 {
                     "EndsWith",
-                    new SqlBuiltinFunctionVisitor("ENDSWITH",
-                    false,
-                    new List<Type[]>
-                    {
-                        new Type[]{typeof(string)}
-                    })
+                    new SqlStringWithComparisonVisitor("ENDSWITH")
                 },
                 {
                     "IndexOf",
@@ -313,12 +383,7 @@ static StringBuiltinFunctions()
                 },
                 {
                     "StartsWith",
-                    new SqlBuiltinFunctionVisitor("STARTSWITH",
-                    false,
-                    new List<Type[]>
-                    {
-                        new Type[]{typeof(string)}
-                    })
+                    new SqlStringWithComparisonVisitor("STARTSWITH")
                 },
                 {
                     "Substring",

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

@@ -13,6 +13,7 @@ namespace Microsoft.Azure.Cosmos.SDK.EmulatorTests
     using System.Collections.ObjectModel;
     using System.Linq;
     using System.Linq.Dynamic;
+    using System.Linq.Expressions;
     using System.Threading.Tasks;
 
     [TestClass]
@@ -712,6 +713,50 @@ public async Task LinqParameterisedTest3()
 
         }
 
+        [TestMethod]
+        public async Task LinqCaseInsensitiveStringTest()
+        {
+            //Creating items for query.
+            IList<ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(container: this.Container, pkCount: 2, perPKItemCount: 1, randomPartitionKey: true);
+
+            IOrderedQueryable<ToDoActivity> linqQueryable = this.Container.GetItemLinqQueryable<ToDoActivity>();
+
+            async Task TestSearch(Expression<Func<ToDoActivity, bool>> expression, string expectedMethod, bool shouldBeCaseInsensitive, int expectedResults)
+            {
+                string expectedQueryText = $"SELECT VALUE root FROM root WHERE {expectedMethod}(root[\"description\"], @param1{(shouldBeCaseInsensitive ? ", true" : "")})";
+
+                IArgumentProvider arguments = (IArgumentProvider)expression.Body;
+                int index = arguments.ArgumentCount > 2 ? 1 : 0;
+
+                string searchString = (arguments.GetArgument(index) as ConstantExpression).Value as string;
+
+                IQueryable<ToDoActivity> queryable = linqQueryable.Where(expression);
+
+                Dictionary<object, string> parameters = new Dictionary<object, string>();
+                parameters.Add(searchString, "@param1");
+
+                QueryDefinition queryDefinition = queryable.ToQueryDefinition(parameters);
+
+                string queryText = queryDefinition.ToSqlQuerySpec().QueryText;
+
+                Assert.AreEqual(expectedQueryText, queryText);
+
+                Assert.AreEqual(expectedResults, await queryable.CountAsync());
+            }
+
+            await TestSearch(x => x.description.StartsWith("create"), "STARTSWITH", false, 0);
+            await TestSearch(x => x.description.StartsWith("create", StringComparison.OrdinalIgnoreCase), "STARTSWITH", true, 2);
+
+            await TestSearch(x => x.description.EndsWith("activity"), "ENDSWITH", false, 0);
+            await TestSearch(x => x.description.EndsWith("activity", StringComparison.OrdinalIgnoreCase), "ENDSWITH", true, 2);
+
+            await TestSearch(x => x.description.Equals("createrandomtodoactivity", StringComparison.OrdinalIgnoreCase), "STRINGEQUALS", true, 2);
+
+            await TestSearch(x => x.description.Contains("todo"), "CONTAINS", false, 0);
+            await TestSearch(x => x.description.Contains("todo", StringComparison.OrdinalIgnoreCase), "CONTAINS", true, 2);
+
+        }
+
         private class NumberLinqItem
         {
             public string id;
@@ -764,4 +809,12 @@ private void VerifyResponse<T>(
                 disableDiagnostics: disableDiagnostics);
         }
     }
+
+    static class StringTestExtensions
+    {
+        public static bool Contains(this string haystack, string needle, StringComparison stringComparison)
+        {
+            throw new NotImplementedException("Method for testing SQL translation only");
+        }
+    }
 }