Support any expression type inside inline primitive collections

Closes #30732
Closes #30734

Author: roji

src/EFCore.Cosmos/Properties/CosmosStrings.Designer.cs

@@ -123,6 +123,9 @@
   <data name="CanConnectNotSupported" xml:space="preserve">
     <value>The Cosmos database does not support 'CanConnect' or 'CanConnectAsync'.</value>
   </data>
+  <data name="CannotTranslateNonConstantNewArrayExpression" xml:space="preserve">
+    <value>The query contained a new array expression containing non-constant elements, which could not be translated: '{newArrayExpression}'.</value>
+  </data>
   <data name="ConnectionStringConflictingConfiguration" xml:space="preserve">
     <value>Both the connection string and CredentialToken, account key or account endpoint were specified. Specify only one set of connection details.</value>
   </data>

src/EFCore.Cosmos/Properties/CosmosStrings.resx

@@ -4,6 +4,7 @@
 #nullable disable
 
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.EntityFrameworkCore.Cosmos.Internal;
 
 namespace Microsoft.EntityFrameworkCore.Cosmos.Query.Internal;
@@ -429,7 +430,9 @@ protected override Expression VisitMember(MemberExpression memberExpression)
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
     protected override Expression VisitMemberInit(MemberInitExpression memberInitExpression)
-        => GetConstantOrNull(memberInitExpression);
+        => TryEvaluateToConstant(memberInitExpression, out var sqlConstantExpression)
+            ? sqlConstantExpression
+            : QueryCompilationContext.NotTranslatedExpression;
 
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -603,7 +606,9 @@ static Expression RemoveObjectConvert(Expression expression)
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
     protected override Expression VisitNew(NewExpression newExpression)
-        => GetConstantOrNull(newExpression);
+        => TryEvaluateToConstant(newExpression, out var sqlConstantExpression)
+            ? sqlConstantExpression
+            : QueryCompilationContext.NotTranslatedExpression;
 
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -612,7 +617,15 @@ protected override Expression VisitNew(NewExpression newExpression)
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
     protected override Expression VisitNewArray(NewArrayExpression newArrayExpression)
-        => null;
+    {
+        if (TryEvaluateToConstant(newArrayExpression, out var sqlConstantExpression))
+        {
+            return sqlConstantExpression;
+        }
+
+        AddTranslationErrorDetails(CosmosStrings.CannotTranslateNonConstantNewArrayExpression(newArrayExpression.Print()));
+        return QueryCompilationContext.NotTranslatedExpression;
+    }
 
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -990,38 +1003,34 @@ private static List<TProperty> ParameterListValueExtractor<TEntity, TProperty>(
     private static bool IsNullSqlConstantExpression(Expression expression)
         => expression is SqlConstantExpression sqlConstant && sqlConstant.Value == null;
 
-    private static SqlConstantExpression GetConstantOrNull(Expression expression)
-        => CanEvaluate(expression)
-            ? new SqlConstantExpression(
+    private static bool TryEvaluateToConstant(Expression expression, out SqlConstantExpression sqlConstantExpression)
+    {
+        if (CanEvaluate(expression))
+        {
+            sqlConstantExpression = new SqlConstantExpression(
                 Expression.Constant(
                     Expression.Lambda<Func<object>>(Expression.Convert(expression, typeof(object)))
                         .Compile(preferInterpretation: true)
                         .Invoke(),
                     expression.Type),
-                null)
-            : null;
+                null);
+            return true;
+        }
+
+        sqlConstantExpression = null;
+        return false;
+    }
 
     private static bool CanEvaluate(Expression expression)
-    {
-#pragma warning disable IDE0066 // Convert switch statement to expression
-        switch (expression)
-#pragma warning restore IDE0066 // Convert switch statement to expression
+        => expression switch
         {
-            case ConstantExpression:
-                return true;
-
-            case NewExpression newExpression:
-                return newExpression.Arguments.All(e => CanEvaluate(e));
-
-            case MemberInitExpression memberInitExpression:
-                return CanEvaluate(memberInitExpression.NewExpression)
-                    && memberInitExpression.Bindings.All(
-                        mb => mb is MemberAssignment memberAssignment && CanEvaluate(memberAssignment.Expression));
-
-            default:
-                return false;
-        }
-    }
+            ConstantExpression => true,
+            NewExpression e => e.Arguments.All(CanEvaluate),
+            NewArrayExpression e => e.Expressions.All(CanEvaluate),
+            MemberInitExpression e => CanEvaluate(e.NewExpression)
+                && e.Bindings.All(mb => mb is MemberAssignment memberAssignment && CanEvaluate(memberAssignment.Expression)),
+            _ => false
+        };
 
     [DebuggerStepThrough]
     private static bool TranslationFailed(Expression original, Expression translation, out SqlExpression castTranslation)

src/EFCore.Cosmos/Query/Internal/CosmosSqlTranslatingExpressionVisitor.cs

@@ -130,6 +130,9 @@
   <data name="CannotChangeWhenOpen" xml:space="preserve">
     <value>The instance of DbConnection is currently in use. The connection can only be changed when the existing connection is not being used.</value>
   </data>
+  <data name="CannotTranslateNonConstantNewArrayExpression" xml:space="preserve">
+    <value>The query contained a new array expression containing non-constant elements, which could not be translated: '{newArrayExpression}'.</value>
+  </data>
   <data name="CannotConfigureTriggerNonRootTphEntity" xml:space="preserve">
     <value>Can't configure a trigger on entity type '{entityType}', which is in a TPH hierarchy and isn't the root. Configure the trigger on the TPH root entity type '{rootEntityType}' instead.</value>
   </data>
@@ -346,8 +349,8 @@
   <data name="DuplicateSeedDataSensitive" xml:space="preserve">
     <value>A seed entity for entity type '{entityType}' has the same key value {keyValue} as another seed entity mapped to the same table '{table}'. Key values should be unique across seed entities.</value>
   </data>
-  <data name="EitherOfTwoValuesMustBeNull" xml:space="preserve">
-    <value>Either {param1} or {param2} must be null.</value>
+  <data name="OneOfThreeValuesMustBeSet" xml:space="preserve">
+    <value>Exactly one of '{param1}', '{param2}' or '{param3}' must be set.</value>
   </data>
   <data name="EmptyCollectionNotSupportedAsInlineQueryRoot" xml:space="preserve">
     <value>Empty collections are not supported as inline query roots.</value>
@@ -911,8 +914,8 @@
   <data name="NoDbCommand" xml:space="preserve">
     <value>Cannot create a DbCommand for a non-relational query.</value>
   </data>
-  <data name="NonConstantOrParameterAsInExpressionValues" xml:space="preserve">
-    <value>Expression of type '{type}' isn't supported as the Values of an InExpression; only constants and parameters are supported.</value>
+  <data name="NonConstantOrParameterAsInExpressionValue" xml:space="preserve">
+    <value>Expression of type '{type}' isn't supported in the values of an InExpression; only constants and parameters are supported.</value>
   </data>
   <data name="NoneRelationalTypeMappingOnARelationalTypeMappingSource" xml:space="preserve">
     <value>'FindMapping' was called on a 'RelationalTypeMappingSource' with a non-relational 'TypeMappingInfo'.</value>

src/EFCore.Relational/Properties/RelationalStrings.Designer.cs

@@ -402,21 +402,29 @@ SqlFunctionExpression NiladicFunction(
     /// <returns>An expression representing an EXISTS operation in a SQL tree.</returns>
     ExistsExpression Exists(SelectExpression subquery);
 
+    /// <summary>
+    ///     Creates a new <see cref="InExpression" /> which represents an IN operation in a SQL tree.
+    /// </summary>
+    /// <param name="item">An item to look into values.</param>
+    /// <param name="subquery">A subquery in which item is searched.</param>
+    /// <returns>An expression representing an IN operation in a SQL tree.</returns>
+    InExpression In(SqlExpression item, SelectExpression subquery);
+
     /// <summary>
     ///     Creates a new <see cref="InExpression" /> which represents an IN operation in a SQL tree.
     /// </summary>
     /// <param name="item">An item to look into values.</param>
     /// <param name="values">A list of values in which item is searched.</param>
     /// <returns>An expression representing an IN operation in a SQL tree.</returns>
-    InExpression In(SqlExpression item, SqlExpression values);
+    InExpression In(SqlExpression item, IReadOnlyList<SqlExpression> values);
 
     /// <summary>
     ///     Creates a new <see cref="InExpression" /> which represents an IN operation in a SQL tree.
     /// </summary>
     /// <param name="item">An item to look into values.</param>
-    /// <param name="subquery">A subquery in which item is searched.</param>
+    /// <param name="valuesParameter">A parameterized list of values in which the item is searched.</param>
     /// <returns>An expression representing an IN operation in a SQL tree.</returns>
-    InExpression In(SqlExpression item, SelectExpression subquery);
+    InExpression In(SqlExpression item, SqlParameterExpression valuesParameter);
 
     /// <summary>
     ///     Creates a new <see cref="InExpression" /> which represents a LIKE in a SQL tree.

src/EFCore.Relational/Properties/RelationalStrings.resx

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections;
 using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
 
 namespace Microsoft.EntityFrameworkCore.Query.Internal;
@@ -38,26 +39,48 @@ public ContainsTranslator(ISqlExpressionFactory sqlExpressionFactory)
         IReadOnlyList<SqlExpression> arguments,
         IDiagnosticsLogger<DbLoggerCategory.Query> logger)
     {
+        SqlExpression? itemExpression = null, valuesExpression = null;
+
+        // Identify static Enumerable.Contains and instance List.Contains
         if (method.IsGenericMethod
-            && method.GetGenericMethodDefinition().Equals(EnumerableMethods.Contains)
+            && method.GetGenericMethodDefinition() == EnumerableMethods.Contains
             && ValidateValues(arguments[0]))
         {
-            return _sqlExpressionFactory.In(RemoveObjectConvert(arguments[1]), arguments[0]);
+            (itemExpression, valuesExpression) = (RemoveObjectConvert(arguments[1]), arguments[0]);
         }
 
         if (arguments.Count == 1
             && method.IsContainsMethod()
             && instance != null
             && ValidateValues(instance))
         {
-            return _sqlExpressionFactory.In(RemoveObjectConvert(arguments[0]), instance);
+            (itemExpression, valuesExpression) = (RemoveObjectConvert(arguments[0]), instance);
+        }
+
+        if (itemExpression is not null && valuesExpression is not null)
+        {
+            switch (valuesExpression)
+            {
+                case SqlParameterExpression parameter:
+                    return _sqlExpressionFactory.In(itemExpression, parameter);
+
+                case SqlConstantExpression { Value: IEnumerable values }:
+                    var valuesExpressions = new List<SqlExpression>();
+
+                    foreach (var value in values)
+                    {
+                        valuesExpressions.Add(_sqlExpressionFactory.Constant(value));
+                    }
+
+                    return _sqlExpressionFactory.In(itemExpression, valuesExpressions);
+            }
         }
 
         return null;
     }
 
     private static bool ValidateValues(SqlExpression values)
-        => values is SqlConstantExpression || values is SqlParameterExpression;
+        => values is SqlConstantExpression or SqlParameterExpression;
 
     private static SqlExpression RemoveObjectConvert(SqlExpression expression)
         => expression is SqlUnaryExpression sqlUnaryExpression

src/EFCore.Relational/Query/ISqlExpressionFactory.cs

@@ -130,38 +130,58 @@ public virtual Expression Expand(
                 return _visitedFromSqlExpressions[fromSql] = fromSql.Update(
                     Expression.Constant(new CompositeRelationalParameter(parameterExpression.Name!, subParameters)));
 
-            case ConstantExpression constantExpression:
-                var existingValues = constantExpression.GetConstantValue<object?[]>();
+            case ConstantExpression { Value: object?[] existingValues }:
+            {
                 var constantValues = new object?[existingValues.Length];
                 for (var i = 0; i < existingValues.Length; i++)
                 {
-                    var value = existingValues[i];
-                    if (value is DbParameter dbParameter)
-                    {
-                        var parameterName = _parameterNameGenerator.GenerateNext();
-                        if (string.IsNullOrEmpty(dbParameter.ParameterName))
-                        {
-                            dbParameter.ParameterName = parameterName;
-                        }
-                        else
-                        {
-                            parameterName = dbParameter.ParameterName;
-                        }
+                    constantValues[i] = ProcessConstantValue(existingValues[i]);
+                }
 
-                        constantValues[i] = new RawRelationalParameter(parameterName, dbParameter);
-                    }
-                    else
+                return _visitedFromSqlExpressions[fromSql] = fromSql.Update(Expression.Constant(constantValues, typeof(object[])));
+            }
+
+            case NewArrayExpression { Expressions: var expressions }:
+            {
+                var constantValues = new object?[expressions.Count];
+                for (var i = 0; i < constantValues.Length; i++)
+                {
+                    if (expressions[i] is not SqlConstantExpression { Value: var existingValue })
                     {
-                        constantValues[i] = _sqlExpressionFactory.Constant(
-                            value, _typeMappingSource.GetMappingForValue(value));
+                        Check.DebugFail("FromSql.Arguments must be Constant/ParameterExpression");
+                        throw new InvalidOperationException();
                     }
+
+                    constantValues[i] = ProcessConstantValue(existingValue);
                 }
 
                 return _visitedFromSqlExpressions[fromSql] = fromSql.Update(Expression.Constant(constantValues, typeof(object[])));
+            }
 
             default:
                 Check.DebugFail("FromSql.Arguments must be Constant/ParameterExpression");
                 return null;
         }
+
+        object ProcessConstantValue(object? existingConstantValue)
+        {
+            if (existingConstantValue is DbParameter dbParameter)
+            {
+                var parameterName = _parameterNameGenerator.GenerateNext();
+                if (string.IsNullOrEmpty(dbParameter.ParameterName))
+                {
+                    dbParameter.ParameterName = parameterName;
+                }
+                else
+                {
+                    parameterName = dbParameter.ParameterName;
+                }
+
+                return new RawRelationalParameter(parameterName, dbParameter);
+            }
+
+            return _sqlExpressionFactory.Constant(
+                existingConstantValue, _typeMappingSource.GetMappingForValue(existingConstantValue));
+        }
     }
 }