Query: Change RelationalCommandCache to allow non-SelectExpression as query expression

src/EFCore.Relational/Query/Internal/FromSqlParameterExpandingExpressionVisitor.cs

@@ -26,7 +26,6 @@ private readonly IDictionary<FromSqlExpression, Expression> _visitedFromSqlExpre
  private IReadOnlyDictionary<string, object?> _parametersValues;
  private ParameterNameGenerator _parameterNameGenerator;
  private bool _canCache;
- private SelectExpression _selectExpression;
 
  /// <summary>
  /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -44,7 +43,6 @@ public FromSqlParameterExpandingExpressionVisitor(
  _parameterNameGeneratorFactory = dependencies.ParameterNameGeneratorFactory;
  _parametersValues = default!;
  _parameterNameGenerator = default!;
- _selectExpression = default!;
  }
 
  /// <summary>
@@ -58,18 +56,17 @@ public FromSqlParameterExpandingExpressionVisitor(
  /// any release. You should only use it directly in your code with extreme caution and knowing that
  /// doing so can result in application failures when updating to a new Entity Framework Core release.
  /// </summary>
- public virtual SelectExpression Expand(
- SelectExpression selectExpression,
+ public virtual Expression Expand(
+ Expression queryExpression,
  IReadOnlyDictionary<string, object?> parameterValues,
  out bool canCache)
  {
  _visitedFromSqlExpressions.Clear();
  _parameterNameGenerator = _parameterNameGeneratorFactory.Create();
  _parametersValues = parameterValues;
  _canCache = true;
- _selectExpression = selectExpression;
 
- var result = (SelectExpression)Visit(selectExpression);
+ var result = Visit(queryExpression);
  canCache = _canCache;
 
  return result;

src/EFCore.Relational/Query/Internal/RelationalCommandCache.cs

@@ -21,7 +21,7 @@ private static readonly ConcurrentDictionary<object, object> Locks
 
  private readonly IMemoryCache _memoryCache;
  private readonly IQuerySqlGeneratorFactory _querySqlGeneratorFactory;
- private readonly SelectExpression _selectExpression;
+ private readonly Expression _queryExpression;
  private readonly RelationalParameterBasedSqlProcessor _relationalParameterBasedSqlProcessor;
 
  /// <summary>
@@ -34,12 +34,12 @@ public RelationalCommandCache(
  IMemoryCache memoryCache,
  IQuerySqlGeneratorFactory querySqlGeneratorFactory,
  IRelationalParameterBasedSqlProcessorFactory relationalParameterBasedSqlProcessorFactory,
- SelectExpression selectExpression,
+ Expression queryExpression,
  bool useRelationalNulls)
  {
  _memoryCache = memoryCache;
  _querySqlGeneratorFactory = querySqlGeneratorFactory;
- _selectExpression = selectExpression;
+ _queryExpression = queryExpression;
  _relationalParameterBasedSqlProcessor = relationalParameterBasedSqlProcessorFactory.Create(useRelationalNulls);
  }
 
@@ -51,7 +51,7 @@ public RelationalCommandCache(
  /// </summary>
  public virtual IRelationalCommandTemplate GetRelationalCommandTemplate(IReadOnlyDictionary<string, object?> parameters)
  {
- var cacheKey = new CommandCacheKey(_selectExpression, parameters);
+ var cacheKey = new CommandCacheKey(_queryExpression, parameters);
 
  if (_memoryCache.TryGetValue(cacheKey, out IRelationalCommandTemplate? relationalCommandTemplate))
  {
@@ -69,9 +69,9 @@ public virtual IRelationalCommandTemplate GetRelationalCommandTemplate(IReadOnly
  {
  if (!_memoryCache.TryGetValue(cacheKey, out relationalCommandTemplate))
  {
- var selectExpression = _relationalParameterBasedSqlProcessor.Optimize(
- _selectExpression, parameters, out var canCache);
- relationalCommandTemplate = _querySqlGeneratorFactory.Create().GetCommand(selectExpression);
+ var queryExpression = _relationalParameterBasedSqlProcessor.Optimize(
+ _queryExpression, parameters, out var canCache);
+ relationalCommandTemplate = _querySqlGeneratorFactory.Create().GetCommand(queryExpression);
 
  if (canCache)
  {
@@ -96,22 +96,22 @@ public virtual IRelationalCommandTemplate GetRelationalCommandTemplate(IReadOnly
  /// </summary>
  void IPrintableExpression.Print(ExpressionPrinter expressionPrinter)
  {
- expressionPrinter.AppendLine("RelationalCommandCache.SelectExpression(");
+ expressionPrinter.AppendLine("RelationalCommandCache.QueryExpression(");
  using (expressionPrinter.Indent())
  {
- expressionPrinter.Visit(_selectExpression);
+ expressionPrinter.Visit(_queryExpression);
  expressionPrinter.Append(")");
  }
  }
 
  private readonly struct CommandCacheKey : IEquatable<CommandCacheKey>
  {
- private readonly SelectExpression _selectExpression;
+ private readonly Expression _queryExpression;
  private readonly IReadOnlyDictionary<string, object?> _parameterValues;
 
- public CommandCacheKey(SelectExpression selectExpression, IReadOnlyDictionary<string, object?> parameterValues)
+ public CommandCacheKey(Expression queryExpression, IReadOnlyDictionary<string, object?> parameterValues)
  {
- _selectExpression = selectExpression;
+ _queryExpression = queryExpression;
  _parameterValues = parameterValues;
  }
 
@@ -121,7 +121,8 @@ public override bool Equals(object? obj)
 
  public bool Equals(CommandCacheKey commandCacheKey)
  {
- if (!ReferenceEquals(_selectExpression, commandCacheKey._selectExpression))
+ // Intentionally reference equals
+ if (!ReferenceEquals(_queryExpression, commandCacheKey._queryExpression))
  {
  return false;
  }

src/EFCore.Relational/Query/QuerySqlGenerator.cs

@@ -61,23 +61,33 @@ public QuerySqlGenerator(QuerySqlGeneratorDependencies dependencies)
  protected virtual QuerySqlGeneratorDependencies Dependencies { get; }
 
  /// <summary>
- /// Gets a relational command for a <see cref="SelectExpression" />.
+ /// Gets a relational command for a query expression.
  /// </summary>
- /// <param name="selectExpression">A select expression to print in command text.</param>
- /// <returns>A relational command with a SQL represented by the select expression.</returns>
- public virtual IRelationalCommand GetCommand(SelectExpression selectExpression)
+ /// <param name="queryExpression">A query expression to print in command text.</param>
+ /// <returns>A relational command with a SQL represented by the query expression.</returns>
+ public virtual IRelationalCommand GetCommand(Expression queryExpression)
  {
  _relationalCommandBuilder = _relationalCommandBuilderFactory.Create();
 
- GenerateTagsHeaderComment(selectExpression);
-
- if (selectExpression.IsNonComposedFromSql())
- {
- GenerateFromSql((FromSqlExpression)selectExpression.Tables[0]);
- }
- else
+ switch (queryExpression)
  {
- VisitSelect(selectExpression);
+ case SelectExpression selectExpression:
+ {
+ GenerateTagsHeaderComment(selectExpression);
+
+ if (selectExpression.IsNonComposedFromSql())
+ {
+ GenerateFromSql((FromSqlExpression)selectExpression.Tables[0]);
+ }
+ else
+ {
+ VisitSelect(selectExpression);
+ }
+ }
+ break;
+
+ default:
+ throw new InvalidOperationException();
  }
 
  return _relationalCommandBuilder.Build();

src/EFCore.Relational/Query/RelationalParameterBasedSqlProcessor.cs

@@ -8,7 +8,7 @@ namespace Microsoft.EntityFrameworkCore.Query;
 
 /// <summary>
 /// <para>
-/// A class that processes the <see cref="SelectExpression" />  after parementer values are known.
+/// A class that processes the query expression after parementer values are known.
 /// </para>
 /// <para>
 /// This type is typically used by database providers (and other extensions). It is generally
@@ -18,7 +18,7 @@ namespace Microsoft.EntityFrameworkCore.Query;
 public class RelationalParameterBasedSqlProcessor
 {
  /// <summary>
- /// Creates a new instance of the <see cref="QueryTranslationPostprocessor" /> class.
+ /// Creates a new instance of the <see cref="RelationalParameterBasedSqlProcessor" /> class.
  /// </summary>
  /// <param name="dependencies">Parameter object containing dependencies for this class.</param>
  /// <param name="useRelationalNulls">A bool value indicating if relational nulls should be used.</param>
@@ -41,51 +41,51 @@ public RelationalParameterBasedSqlProcessor(
  protected virtual bool UseRelationalNulls { get; }
 
  /// <summary>
- /// Optimizes the <see cref="SelectExpression" /> for given parameter values.
+ /// Optimizes the query expression for given parameter values.
  /// </summary>
- /// <param name="selectExpression">A select expression to optimize.</param>
+ /// <param name="queryExpression">A query expression to optimize.</param>
  /// <param name="parametersValues">A dictionary of parameter values to use.</param>
- /// <param name="canCache">A bool value indicating if the select expression can be cached.</param>
- /// <returns>An optimized select expression.</returns>
- public virtual SelectExpression Optimize(
- SelectExpression selectExpression,
+ /// <param name="canCache">A bool value indicating if the query expression can be cached.</param>
+ /// <returns>An optimized query expression.</returns>
+ public virtual Expression Optimize(
+ Expression queryExpression,
  IReadOnlyDictionary<string, object?> parametersValues,
  out bool canCache)
  {
  canCache = true;
- selectExpression = ProcessSqlNullability(selectExpression, parametersValues, out var sqlNullablityCanCache);
+ queryExpression = ProcessSqlNullability(queryExpression, parametersValues, out var sqlNullablityCanCache);
  canCache &= sqlNullablityCanCache;
 
- selectExpression = ExpandFromSqlParameter(selectExpression, parametersValues, out var fromSqlParameterCanCache);
+ queryExpression = ExpandFromSqlParameter(queryExpression, parametersValues, out var fromSqlParameterCanCache);
  canCache &= fromSqlParameterCanCache;
 
- return selectExpression;
+ return queryExpression;
  }
 
  /// <summary>
- /// Processes the <see cref="SelectExpression" /> based on nullability of nodes to apply null semantics in use and
+ /// Processes the query expression based on nullability of nodes to apply null semantics in use and
  /// optimize it for given parameter values.
  /// </summary>
- /// <param name="selectExpression">A select expression to optimize.</param>
+ /// <param name="queryExpression">A query expression to optimize.</param>
  /// <param name="parametersValues">A dictionary of parameter values to use.</param>
- /// <param name="canCache">A bool value indicating if the select expression can be cached.</param>
- /// <returns>A processed select expression.</returns>
- protected virtual SelectExpression ProcessSqlNullability(
- SelectExpression selectExpression,
+ /// <param name="canCache">A bool value indicating if the query expression can be cached.</param>
+ /// <returns>A processed query expression.</returns>
+ protected virtual Expression ProcessSqlNullability(
+ Expression queryExpression,
  IReadOnlyDictionary<string, object?> parametersValues,
  out bool canCache)
- => new SqlNullabilityProcessor(Dependencies, UseRelationalNulls).Process(selectExpression, parametersValues, out canCache);
+ => new SqlNullabilityProcessor(Dependencies, UseRelationalNulls).Process(queryExpression, parametersValues, out canCache);
 
  /// <summary>
- /// Expands the parameters to <see cref="FromSqlExpression" /> inside the <see cref="SelectExpression" /> for given parameter values.
+ /// Expands the parameters to <see cref="FromSqlExpression" /> inside the query expression for given parameter values.
  /// </summary>
- /// <param name="selectExpression">A select expression to optimize.</param>
+ /// <param name="queryExpression">A query expression to optimize.</param>
  /// <param name="parametersValues">A dictionary of parameter values to use.</param>
- /// <param name="canCache">A bool value indicating if the select expression can be cached.</param>
- /// <returns>A processed select expression.</returns>
- protected virtual SelectExpression ExpandFromSqlParameter(
- SelectExpression selectExpression,
+ /// <param name="canCache">A bool value indicating if the query expression can be cached.</param>
+ /// <returns>A processed query expression.</returns>
+ protected virtual Expression ExpandFromSqlParameter(
+ Expression queryExpression,
  IReadOnlyDictionary<string, object?> parametersValues,
  out bool canCache)
- => new FromSqlParameterExpandingExpressionVisitor(Dependencies).Expand(selectExpression, parametersValues, out canCache);
+ => new FromSqlParameterExpandingExpressionVisitor(Dependencies).Expand(queryExpression, parametersValues, out canCache);
 }

src/EFCore.Relational/Query/SqlNullabilityProcessor.cs

@@ -59,14 +59,14 @@ public SqlNullabilityProcessor(
  protected virtual IReadOnlyDictionary<string, object?> ParameterValues { get; private set; }
 
  /// <summary>
- /// Processes a <see cref="SelectExpression" /> to apply null semantics and optimize it.
+ /// Processes a query expression to apply null semantics and optimize it.
  /// </summary>
- /// <param name="selectExpression">A select expression to process.</param>
+ /// <param name="queryExpression">A query expression to process.</param>
  /// <param name="parameterValues">A dictionary of parameter values in use.</param>
- /// <param name="canCache">A bool value indicating whether the select expression can be cached.</param>
- /// <returns>An optimized select expression.</returns>
- public virtual SelectExpression Process(
- SelectExpression selectExpression,
+ /// <param name="canCache">A bool value indicating whether the query expression can be cached.</param>
+ /// <returns>An optimized query expression.</returns>
+ public virtual Expression Process(
+ Expression queryExpression,
  IReadOnlyDictionary<string, object?> parameterValues,
  out bool canCache)
  {
@@ -75,7 +75,11 @@ public virtual SelectExpression Process(
  _nullValueColumns.Clear();
  ParameterValues = parameterValues;
 
- var result = Visit(selectExpression);
+ var result = queryExpression switch
+ {
+ SelectExpression selectExpression => Visit(selectExpression),
+ _ => throw new InvalidOperationException()
+ };
  canCache = _canCache;
 
  return result;

src/EFCore.SqlServer/Query/Internal/SkipTakeCollapsingExpressionVisitor.cs

@@ -36,15 +36,15 @@ public SkipTakeCollapsingExpressionVisitor(ISqlExpressionFactory sqlExpressionFa
  /// any release. You should only use it directly in your code with extreme caution and knowing that
  /// doing so can result in application failures when updating to a new Entity Framework Core release.
  /// </summary>
- public virtual SelectExpression Process(
- SelectExpression selectExpression,
+ public virtual Expression Process(
+ Expression queryExpression,
  IReadOnlyDictionary<string, object?> parametersValues,
  out bool canCache)
  {
  _parameterValues = parametersValues;
  _canCache = true;
 
- var result = (SelectExpression)Visit(selectExpression);
+ var result = Visit(queryExpression);
 
  canCache = _canCache;
 

src/EFCore.SqlServer/Query/Internal/SqlServerParameterBasedSqlProcessor.cs

@@ -32,19 +32,18 @@ public SqlServerParameterBasedSqlProcessor(
  /// any release. You should only use it directly in your code with extreme caution and knowing that
  /// doing so can result in application failures when updating to a new Entity Framework Core release.
  /// </summary>
- public override SelectExpression Optimize(
- SelectExpression selectExpression,
+ public override Expression Optimize(
+ Expression queryExpression,
  IReadOnlyDictionary<string, object?> parametersValues,
  out bool canCache)
  {
- var optimizedSelectExpression = base.Optimize(selectExpression, parametersValues, out canCache);
+ var optimizedQueryExpression = base.Optimize(queryExpression, parametersValues, out canCache);
 
- optimizedSelectExpression = new SkipTakeCollapsingExpressionVisitor(Dependencies.SqlExpressionFactory)
- .Process(optimizedSelectExpression, parametersValues, out var canCache2);
+ optimizedQueryExpression = new SkipTakeCollapsingExpressionVisitor(Dependencies.SqlExpressionFactory)
+ .Process(optimizedQueryExpression, parametersValues, out var canCache2);
 
  canCache &= canCache2;
 
- return (SelectExpression)new SearchConditionConvertingExpressionVisitor(Dependencies.SqlExpressionFactory)
- .Visit(optimizedSelectExpression);
+ return new SearchConditionConvertingExpressionVisitor(Dependencies.SqlExpressionFactory).Visit(optimizedQueryExpression);
  }
 }