Query : Adds string comparison alternative when converting LINQ to SQL

Microsoft.Azure.Cosmos/src/ClientResources.resx

@@ -270,9 +270,15 @@
   <data name="StringCompareToInvalidConstant" xml:space="preserve">
     <value>The right hand side of string.CompareTo() comparison must be constant '0'</value>
   </data>
+  <data name="StringCompareInvalidConstant" xml:space="preserve">
+    <value>The right hand side of string.Compare() comparison must be constant '0'</value>
+  </data>
   <data name="StringCompareToInvalidOperator" xml:space="preserve">
     <value>Invalid operator for string.CompareTo(). Vaid operators are ('==', '&lt;', '&lt;=', '&gt;' or '&gt;=')</value>
   </data>
+  <data name="StringCompareInvalidOperator" xml:space="preserve">
+    <value>Invalid operator for string.Compare(). Vaid operators are ('==', '&lt;', '&lt;=', '&gt;' or '&gt;=')</value>
+  </data>
   <data name="TokenRefreshInProgress" xml:space="preserve">
     <value>Token refresh in progress.</value>
   </data>

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

@@ -457,6 +457,10 @@ private static SqlScalarExpression VisitBinary(BinaryExpression inputExpression,
                 {
                     return ExpressionToSql.VisitStringCompareTo(methodCallExpression, constantExpression, inputExpression.NodeType, reverseNodeType, context);
                 }
+                if (TryMatchStringCompare(methodCallExpression, constantExpression, inputExpression.NodeType))
+                {
+                    return ExpressionToSql.VisitStringCompare(methodCallExpression, constantExpression, inputExpression.NodeType, reverseNodeType, context);
+                }
             }
 
             SqlScalarExpression left = ExpressionToSql.VisitScalarExpression(inputExpression.Left, context);
@@ -615,32 +619,90 @@ private static SqlScalarExpression VisitStringCompareTo(
         {
             if (reverseNodeType)
             {
+                compareOperator = ReverseExpressionTypeForStrings(compareOperator, ClientResources.StringCompareToInvalidOperator);
+            }
+
+            SqlBinaryScalarOperatorKind op = GetBinaryOperatorKind(compareOperator, null);
+
+            SqlScalarExpression leftExpression = ExpressionToSql.VisitNonSubqueryScalarExpression(left.Object, context);
+            SqlScalarExpression rightExpression = ExpressionToSql.VisitNonSubqueryScalarExpression(left.Arguments[0], context);
+
+            return SqlBinaryScalarExpression.Create(op, leftExpression, rightExpression);
+        }
+
+        private static ExpressionType ReverseExpressionTypeForStrings(ExpressionType compareOperator, string errorMessage)
+        {
+            switch (compareOperator)
+            {
+                case ExpressionType.Equal:
+                    // do nothing
+                    break;
+                case ExpressionType.GreaterThan:
+                    compareOperator = ExpressionType.LessThan;
+                    break;
+                case ExpressionType.GreaterThanOrEqual:
+                    compareOperator = ExpressionType.LessThanOrEqual;
+                    break;
+                case ExpressionType.LessThan:
+                    compareOperator = ExpressionType.GreaterThan;
+                    break;
+                case ExpressionType.LessThanOrEqual:
+                    compareOperator = ExpressionType.GreaterThanOrEqual;
+                    break;
+                default:
+                    throw new DocumentQueryException(string.Format(CultureInfo.CurrentCulture, errorMessage));
+            }
+
+            return compareOperator;
+        }
+
+        private static bool TryMatchStringCompare(MethodCallExpression left, ConstantExpression right, ExpressionType compareOperator)
+        {
+            if (left.Method.Equals(typeof(string).GetMethod("Compare", new Type[] { typeof(string), typeof(string) })) && left.Arguments.Count == 2)
+            {
+                // operator can only be =, >, >=, <, <=
                 switch (compareOperator)
                 {
                     case ExpressionType.Equal:
-                        // do nothing
-                        break;
                     case ExpressionType.GreaterThan:
-                        compareOperator = ExpressionType.LessThan;
-                        break;
                     case ExpressionType.GreaterThanOrEqual:
-                        compareOperator = ExpressionType.LessThanOrEqual;
-                        break;
                     case ExpressionType.LessThan:
-                        compareOperator = ExpressionType.GreaterThan;
-                        break;
                     case ExpressionType.LessThanOrEqual:
-                        compareOperator = ExpressionType.GreaterThanOrEqual;
                         break;
                     default:
-                        throw new DocumentQueryException(string.Format(CultureInfo.CurrentCulture, ClientResources.StringCompareToInvalidOperator));
+                        throw new DocumentQueryException(string.Format(CultureInfo.CurrentCulture, ClientResources.StringCompareInvalidOperator));
                 }
+
+                // the constant value should be zero, otherwise we can't determine how to translate the expression
+                // it could be either integer or nullable integer
+                if (!(right.Type == typeof(int) && (int)right.Value == 0) &&
+                    !(right.Type == typeof(int?) && ((int?)right.Value).HasValue && ((int?)right.Value).Value == 0))
+                {
+                    throw new DocumentQueryException(string.Format(CultureInfo.CurrentCulture, ClientResources.StringCompareInvalidConstant));
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        private static SqlScalarExpression VisitStringCompare(
+            MethodCallExpression left,
+            ConstantExpression right,
+            ExpressionType compareOperator,
+            bool reverseNodeType,
+            TranslationContext context)
+        {
+            if (reverseNodeType)
+            {
+                compareOperator = ReverseExpressionTypeForStrings(compareOperator, ClientResources.StringCompareInvalidOperator);
             }
 
             SqlBinaryScalarOperatorKind op = GetBinaryOperatorKind(compareOperator, null);
 
-            SqlScalarExpression leftExpression = ExpressionToSql.VisitNonSubqueryScalarExpression(left.Object, context);
-            SqlScalarExpression rightExpression = ExpressionToSql.VisitNonSubqueryScalarExpression(left.Arguments[0], context);
+            SqlScalarExpression leftExpression = ExpressionToSql.VisitNonSubqueryScalarExpression(left.Arguments[0], context);
+            SqlScalarExpression rightExpression = ExpressionToSql.VisitNonSubqueryScalarExpression(left.Arguments[1], context);
 
             return SqlBinaryScalarExpression.Create(op, leftExpression, rightExpression);
         }