Commits on Aug 30, 2024

1. Reduce lambda compilation for constant evaluation …

   Motivation
   ----------
   We are seeing significant, ongoing JIT compilations and allocations as
   a result of evaluating constants during the query generation process.
   Almost all queries include some reference to a local variable as part
   of the expression tree, such as a reference to the IQueryable<T> itself
   or a filter variable in a Where predicate. These local variables are
   captured as a closure by C# under the covers, and appear a
   MemberAccessExpression with a ConstantExpression as the target.
   Currently, such cases require the JIT compilation of a lambda for
   every single execution of the query.
   
   Modifications
   -------------
   Create an EnhancedPartialEvaluatingExpressionTreeVisitor based upon
   the Relinq PartialEvaluatingExpressionTreeVisitor that evaluates more
   cases using reflection instead of compiling a lambda. This includes the
   mentioned member access case as well as some other common cases.
   Expressions which can't be evaluated in this manner fallback to the
   previous behavior of compiling a lambda and executing it.
   
   Results
   -------
   Significantly less overhead for most queries when computing the
   constant portions of the query. Note that in this context constant means
   a the portion of the query that is known and evaluatable within C#
   without requiring data from the database. It does not necessarily mean
   that the values are constant for each execution of the query.

   

   brantburnett committed Aug 30, 2024
   Configuration menu

   • View commit details
   • Copy full SHA for 1c1d97b
   • Browse repository at this point

   Copy the full SHA

   1c1d97b View commit details

   Browse the repository at this point in the history