/// <summary>
/// Takes an expression tree and finds and evaluates all its evaluatable subtrees.
/// </summary>
public static Expression EvaluateIndependentSubtrees (Expression expressionTree, IEvaluatableExpressionFilter evaluatableExpressionFilter)
{
ArgumentUtility.CheckNotNull ("expressionTree", expressionTree);
ArgumentUtility.CheckNotNull ("evaluatableExpressionFilter", evaluatableExpressionFilter);
var partialEvaluationInfo = EvaluatableTreeFindingExpressionVisitor.Analyze (expressionTree, evaluatableExpressionFilter);
var visitor = new PartialEvaluatingExpressionVisitor (partialEvaluationInfo, evaluatableExpressionFilter);
return visitor.Visit (expressionTree);
}
private PartialEvaluatingExpressionVisitor (
PartialEvaluationInfo partialEvaluationInfo,
IEvaluatableExpressionFilter evaluatableExpressionFilter)
{
ArgumentUtility.CheckNotNull ("partialEvaluationInfo", partialEvaluationInfo);
ArgumentUtility.CheckNotNull ("evaluatableExpressionFilter", evaluatableExpressionFilter);
_partialEvaluationInfo = partialEvaluationInfo;
_evaluatableExpressionFilter = evaluatableExpressionFilter;
}
public PartialEvaluatingExpressionTreeProcessor (IEvaluatableExpressionFilter filter)
{
ArgumentUtility.CheckNotNull ("filter", filter);
_filter = filter;
}
public QueryTranslationPreprocessorDependencies With([NotNull] IEvaluatableExpressionFilter evaluatableExpressionFilter) => new QueryTranslationPreprocessorDependencies(evaluatableExpressionFilter);
public HarmonyNavigationExpandingExpressionVisitor(QueryCompilationContext queryCompilationContext, IEvaluatableExpressionFilter evaluatableExpressionFilter) : base(queryCompilationContext, evaluatableExpressionFilter)
{
}
private EvaluatableTreeFindingExpressionVisitor(IEvaluatableExpressionFilter evaluatableExpressionFilter)
{
_evaluatableExpressionFilter = evaluatableExpressionFilter;
}
public virtual NavigationExpandingExpressionVisitor Create(
QueryTranslationPreprocessor queryTranslationPreprocessor,
QueryCompilationContext queryCompilationContext, IEvaluatableExpressionFilter evaluatableExpressionFilter)
{
return(new RelationalNavigationExpandingExpressionVisitor(queryTranslationPreprocessor, queryCompilationContext, evaluatableExpressionFilter));
}
/// <summary> /// Clones this dependency parameter object with one service replaced. /// </summary> /// <param name="evaluatableExpressionFilter"> A replacement for the current dependency of this type. </param> /// <returns> A new parameter object with the given service replaced. </returns> public QueryOptimizerDependencies With([NotNull] IEvaluatableExpressionFilter evaluatableExpressionFilter) => new QueryOptimizerDependencies(evaluatableExpressionFilter);
public static IRelationalCommand CreateCommand(this IQueryable source, out RelationalQueryContext queryContext)
{
bool EFCore_2_1 = false;
var compilerField = typeof(EntityQueryProvider).GetField("_queryCompiler", BindingFlags.NonPublic | BindingFlags.Instance);
var compiler = compilerField.GetValue(source.Provider);
// REFLECTION: Query.Provider.NodeTypeProvider (Use property for nullable logic)
var nodeTypeProviderProperty = compiler.GetType().GetProperty("NodeTypeProvider", BindingFlags.NonPublic | BindingFlags.Instance);
object nodeTypeProvider;
object QueryModelGenerator = null;
if (nodeTypeProviderProperty == null)
{
EFCore_2_1 = true;
var QueryModelGeneratorField = compiler.GetType().GetField("_queryModelGenerator", BindingFlags.NonPublic | BindingFlags.Instance);
QueryModelGenerator = QueryModelGeneratorField.GetValue(compiler);
var nodeTypeProviderField = QueryModelGenerator.GetType().GetField("_nodeTypeProvider", BindingFlags.NonPublic | BindingFlags.Instance);
nodeTypeProvider = nodeTypeProviderField.GetValue(QueryModelGenerator);
}
else
{
nodeTypeProvider = nodeTypeProviderProperty.GetValue(compiler);
}
var queryContextFactoryField = compiler.GetType().GetField("_queryContextFactory", BindingFlags.NonPublic | BindingFlags.Instance);
var queryContextFactory = (IQueryContextFactory)queryContextFactoryField.GetValue(compiler);
queryContext = (RelationalQueryContext)queryContextFactory.Create();
var databaseField = compiler.GetType().GetField("_database", BindingFlags.NonPublic | BindingFlags.Instance);
var database = (IDatabase)databaseField.GetValue(compiler);
// REFLECTION: Query.Provider._queryCompiler
var queryCompilerField = typeof(EntityQueryProvider).GetField("_queryCompiler", BindingFlags.NonPublic | BindingFlags.Instance);
var queryCompiler = queryCompilerField.GetValue(source.Provider);
// REFLECTION: Query.Provider._queryCompiler._evaluatableExpressionFilter
#if NETSTANDARD2_0
IEvaluatableExpressionFilter evaluatableExpressionFilter = null;
if (EFCore_2_1)
{
evaluatableExpressionFilter = (IEvaluatableExpressionFilter)QueryModelGenerator.GetType().GetField("_evaluatableExpressionFilter", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(QueryModelGenerator);
}
else
{
evaluatableExpressionFilter = (IEvaluatableExpressionFilter)compiler.GetType().GetField("_evaluatableExpressionFilter", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(queryCompiler);
}
#else
var evalutableExpressionFilterField = compiler.GetType().GetField("_evaluatableExpressionFilter", BindingFlags.NonPublic | BindingFlags.Static);
var evalutableExpressionFilter = (IEvaluatableExpressionFilter)evalutableExpressionFilterField.GetValue(null);
var evaluatableExpressionFilterField = queryCompiler.GetType().GetField("_evaluatableExpressionFilter", BindingFlags.NonPublic | BindingFlags.Static);
var evaluatableExpressionFilter = (IEvaluatableExpressionFilter)evaluatableExpressionFilterField.GetValue(null);
#endif
Expression newQuery;
IQueryCompilationContextFactory queryCompilationContextFactory;
var dependenciesProperty = typeof(Database).GetProperty("Dependencies", BindingFlags.NonPublic | BindingFlags.Instance);
if (dependenciesProperty != null)
{
var dependencies = dependenciesProperty.GetValue(database);
var queryCompilationContextFactoryField = typeof(DbContext).GetTypeFromAssembly_Core("Microsoft.EntityFrameworkCore.Storage.DatabaseDependencies")
.GetProperty("QueryCompilationContextFactory", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
queryCompilationContextFactory = (IQueryCompilationContextFactory)queryCompilationContextFactoryField.GetValue(dependencies);
var dependenciesProperty2 = typeof(QueryCompilationContextFactory).GetProperty("Dependencies", BindingFlags.NonPublic | BindingFlags.Instance);
var dependencies2 = dependenciesProperty2.GetValue(queryCompilationContextFactory);
// REFLECTION: Query.Provider._queryCompiler._database._queryCompilationContextFactory.Logger
var loggerField = typeof(DbContext).GetTypeFromAssembly_Core("Microsoft.EntityFrameworkCore.Query.Internal.QueryCompilationContextDependencies")
.GetProperty("Logger", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
var logger = loggerField.GetValue(dependencies2);
var parameterExtractingExpressionVisitorConstructors = typeof(ParameterExtractingExpressionVisitor).GetConstructors();
if (parameterExtractingExpressionVisitorConstructors.Any(x => x.GetParameters().Length == 5))
{
// EF Core 2.1
var parameterExtractingExpressionVisitorConstructor = parameterExtractingExpressionVisitorConstructors.First(x => x.GetParameters().Length == 5);
var parameterExtractingExpressionVisitor = (ParameterExtractingExpressionVisitor)parameterExtractingExpressionVisitorConstructor.Invoke(new object[] { evaluatableExpressionFilter, queryContext, logger, true, false });
// CREATE new query from query visitor
newQuery = parameterExtractingExpressionVisitor.ExtractParameters(source.Expression);
}
else
{
// EF Core 2.1 Preview 2.
var parameterExtractingExpressionVisitorConstructor = parameterExtractingExpressionVisitorConstructors.First(x => x.GetParameters().Length == 6);
var _context = queryContext.GetType().GetProperty("Context", BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.FlattenHierarchy);
var context = _context.GetValue(queryContext);
ParameterExtractingExpressionVisitor parameterExtractingExpressionVisitor = null;
if (parameterExtractingExpressionVisitorConstructor.GetParameters().Where(x => x.ParameterType == typeof(DbContext)).Any())
{
parameterExtractingExpressionVisitor = (ParameterExtractingExpressionVisitor)parameterExtractingExpressionVisitorConstructor.Invoke(new object[] { evaluatableExpressionFilter, queryContext, logger, context, true, false });
}
else
{
parameterExtractingExpressionVisitor = (ParameterExtractingExpressionVisitor)parameterExtractingExpressionVisitorConstructor.Invoke(new object[] { evaluatableExpressionFilter, queryContext, logger, null, true, false });
}
// CREATE new query from query visitor
newQuery = parameterExtractingExpressionVisitor.ExtractParameters(source.Expression);
}
}
else
{
// REFLECTION: Query.Provider._queryCompiler._database._queryCompilationContextFactory
var queryCompilationContextFactoryField = typeof(Database).GetField("_queryCompilationContextFactory", BindingFlags.NonPublic | BindingFlags.Instance);
queryCompilationContextFactory = (IQueryCompilationContextFactory)queryCompilationContextFactoryField.GetValue(database);
// REFLECTION: Query.Provider._queryCompiler._database._queryCompilationContextFactory.Logger
var loggerField = queryCompilationContextFactory.GetType().GetProperty("Logger", BindingFlags.NonPublic | BindingFlags.Instance);
var logger = loggerField.GetValue(queryCompilationContextFactory);
// CREATE new query from query visitor
var extractParametersMethods = typeof(ParameterExtractingExpressionVisitor).GetMethod("ExtractParameters", BindingFlags.Public | BindingFlags.Static);
newQuery = (Expression)extractParametersMethods.Invoke(null, new object[] { source.Expression, queryContext, evaluatableExpressionFilter, logger });
//ParameterExtractingExpressionVisitor.ExtractParameters(source.Expression, queryContext, evaluatableExpressionFilter, logger);
}
//var query = new QueryAnnotatingExpressionVisitor().Visit(source.Expression);
//var newQuery = ParameterExtractingExpressionVisitor.ExtractParameters(query, queryContext, evalutableExpressionFilter);
#if NETSTANDARD2_0
QueryParser queryparser = null;
if (EFCore_2_1)
{
var queryParserMethod = QueryModelGenerator.GetType().GetMethod("CreateQueryParser", BindingFlags.NonPublic | BindingFlags.Instance);
queryparser = (QueryParser)queryParserMethod.Invoke(QueryModelGenerator, new[] { nodeTypeProvider });
}
else
{
var queryParserMethod = compiler.GetType().GetMethod("CreateQueryParser", BindingFlags.NonPublic | BindingFlags.Instance);
queryparser = (QueryParser)queryParserMethod.Invoke(compiler, new[] { nodeTypeProvider });
}
#else
var queryParserMethod = compiler.GetType().GetMethod("CreateQueryParser", BindingFlags.NonPublic | BindingFlags.Static);
var queryparser = (QueryParser)queryParserMethod.Invoke(null, new[] { nodeTypeProvider });
#endif
var queryModel = queryparser.GetParsedQuery(newQuery);
var queryModelVisitor = (RelationalQueryModelVisitor)queryCompilationContextFactory.Create(false).CreateQueryModelVisitor();
var createQueryExecutorMethod = queryModelVisitor.GetType().GetMethod("CreateQueryExecutor");
var createQueryExecutorMethodGeneric = createQueryExecutorMethod.MakeGenericMethod(source.ElementType);
createQueryExecutorMethodGeneric.Invoke(queryModelVisitor, new[] { queryModel });
var queries = queryModelVisitor.Queries;
var sqlQuery = queries.ToList()[0];
var command = sqlQuery.CreateDefaultQuerySqlGenerator().GenerateSql(queryContext.ParameterValues);
return(command);
}
/// <summary>Creates executor and get command.</summary>
/// <returns>The new executor and get command.</returns>
public virtual IRelationalCommand CreateExecutorAndGetCommand(out RelationalQueryContext queryContext)
{
bool isEFCore2x = false;
bool EFCore_2_1 = false;
var context = Query.GetDbContext();
// REFLECTION: Query._context.StateManager
#if NETSTANDARD2_0
var stateManager = context.ChangeTracker.GetStateManager();
#else
var stateManagerProperty = typeof(DbContext).GetProperty("StateManager", BindingFlags.NonPublic | BindingFlags.Instance);
var stateManager = (StateManager)stateManagerProperty.GetValue(context);
#endif
// REFLECTION: Query._context.StateManager._concurrencyDetector
var concurrencyDetectorField = typeof(StateManager).GetField("_concurrencyDetector", BindingFlags.NonPublic | BindingFlags.Instance);
var concurrencyDetector = (IConcurrencyDetector)concurrencyDetectorField.GetValue(stateManager);
// REFLECTION: Query.Provider._queryCompiler
var queryCompilerField = typeof(EntityQueryProvider).GetField("_queryCompiler", BindingFlags.NonPublic | BindingFlags.Instance);
var queryCompiler = queryCompilerField.GetValue(Query.Provider);
// REFLECTION: Query.Provider.NodeTypeProvider (Use property for nullable logic)
var nodeTypeProviderProperty = queryCompiler.GetType().GetProperty("NodeTypeProvider", BindingFlags.NonPublic | BindingFlags.Instance);
object nodeTypeProvider;
object QueryModelGenerator = null;
if (nodeTypeProviderProperty == null)
{
EFCore_2_1 = true;
var QueryModelGeneratorField = queryCompiler.GetType().GetField("_queryModelGenerator", BindingFlags.NonPublic | BindingFlags.Instance);
QueryModelGenerator = QueryModelGeneratorField.GetValue(queryCompiler);
var nodeTypeProviderField = QueryModelGenerator.GetType().GetField("_nodeTypeProvider", BindingFlags.NonPublic | BindingFlags.Instance);
nodeTypeProvider = nodeTypeProviderField.GetValue(QueryModelGenerator);
}
else
{
nodeTypeProvider = nodeTypeProviderProperty.GetValue(queryCompiler);
}
// REFLECTION: Query.Provider._queryCompiler.CreateQueryParser();
#if NETSTANDARD2_0
QueryParser createQueryParser = null;
if (EFCore_2_1)
{
var queryParserMethod = QueryModelGenerator.GetType().GetMethod("CreateQueryParser", BindingFlags.NonPublic | BindingFlags.Instance);
createQueryParser = (QueryParser)queryParserMethod.Invoke(QueryModelGenerator, new[] { nodeTypeProvider });
}
else
{
var queryParserMethod = queryCompiler.GetType().GetMethod("CreateQueryParser", BindingFlags.NonPublic | BindingFlags.Instance);
createQueryParser = (QueryParser)queryParserMethod.Invoke(queryCompiler, new[] { nodeTypeProvider });
}
#else
var createQueryParserMethod = queryCompiler.GetType().GetMethod("CreateQueryParser", BindingFlags.NonPublic | BindingFlags.Static);
var createQueryParser = (QueryParser)createQueryParserMethod.Invoke(null, new[] { nodeTypeProvider });
#endif
// REFLECTION: Query.Provider._queryCompiler._database
var databaseField = queryCompiler.GetType().GetField("_database", BindingFlags.NonPublic | BindingFlags.Instance);
var database = (IDatabase)databaseField.GetValue(queryCompiler);
// REFLECTION: Query.Provider._queryCompiler._evaluatableExpressionFilter
#if NETSTANDARD2_0
IEvaluatableExpressionFilter evaluatableExpressionFilter = null;
if (EFCore_2_1)
{
evaluatableExpressionFilter = (IEvaluatableExpressionFilter)QueryModelGenerator.GetType().GetField("_evaluatableExpressionFilter", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(QueryModelGenerator);
}
else
{
evaluatableExpressionFilter = (IEvaluatableExpressionFilter)queryCompiler.GetType().GetField("_evaluatableExpressionFilter", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(queryCompiler);
}
#else
var evaluatableExpressionFilterField = queryCompiler.GetType().GetField("_evaluatableExpressionFilter", BindingFlags.NonPublic | BindingFlags.Static);
var evaluatableExpressionFilter = (IEvaluatableExpressionFilter)evaluatableExpressionFilterField.GetValue(null);
#endif
// REFLECTION: Query.Provider._queryCompiler._queryContextFactory
var queryContextFactoryField = queryCompiler.GetType().GetField("_queryContextFactory", BindingFlags.NonPublic | BindingFlags.Instance);
var queryContextFactory = (IQueryContextFactory)queryContextFactoryField.GetValue(queryCompiler);
// REFLECTION: Query.Provider._queryCompiler._queryContextFactory.CreateQueryBuffer
var createQueryBufferDelegateMethod = (typeof(QueryContextFactory)).GetMethod("CreateQueryBuffer", BindingFlags.NonPublic | BindingFlags.Instance);
var createQueryBufferDelegate = (Func <IQueryBuffer>)createQueryBufferDelegateMethod.CreateDelegate(typeof(Func <IQueryBuffer>), queryContextFactory);
// REFLECTION: Query.Provider._queryCompiler._queryContextFactory._connection
var connectionField = queryContextFactory.GetType().GetField("_connection", BindingFlags.NonPublic | BindingFlags.Instance);
var connection = (IRelationalConnection)connectionField.GetValue(queryContextFactory);
IQueryCompilationContextFactory queryCompilationContextFactory;
object logger;
var dependenciesProperty = typeof(Database).GetProperty("Dependencies", BindingFlags.NonPublic | BindingFlags.Instance);
if (dependenciesProperty != null)
{
// EFCore 2.x
isEFCore2x = true;
var dependencies = dependenciesProperty.GetValue(database);
var queryCompilationContextFactoryField = typeof(DbContext).GetTypeFromAssembly_Core("Microsoft.EntityFrameworkCore.Storage.DatabaseDependencies")
.GetProperty("QueryCompilationContextFactory", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
queryCompilationContextFactory = (IQueryCompilationContextFactory)queryCompilationContextFactoryField.GetValue(dependencies);
var dependenciesProperty2 = typeof(QueryCompilationContextFactory).GetProperty("Dependencies", BindingFlags.NonPublic | BindingFlags.Instance);
var dependencies2 = dependenciesProperty2.GetValue(queryCompilationContextFactory);
// REFLECTION: Query.Provider._queryCompiler._database._queryCompilationContextFactory.Logger
var loggerField = typeof(DbContext).GetTypeFromAssembly_Core("Microsoft.EntityFrameworkCore.Query.Internal.QueryCompilationContextDependencies")
.GetProperty("Logger", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
// (IInterceptingLogger<LoggerCategory.Query>)
logger = loggerField.GetValue(dependencies2);
}
else
{
// EFCore 1.x
// REFLECTION: Query.Provider._queryCompiler._database._queryCompilationContextFactory
var queryCompilationContextFactoryField = typeof(Database).GetField("_queryCompilationContextFactory", BindingFlags.NonPublic | BindingFlags.Instance);
queryCompilationContextFactory = (IQueryCompilationContextFactory)queryCompilationContextFactoryField.GetValue(database);
// REFLECTION: Query.Provider._queryCompiler._database._queryCompilationContextFactory.Logger
var loggerField = queryCompilationContextFactory.GetType().GetProperty("Logger", BindingFlags.NonPublic | BindingFlags.Instance);
logger = loggerField.GetValue(queryCompilationContextFactory);
}
// CREATE connection
{
QueryConnection = context.Database.GetService <IRelationalConnection>();
var innerConnection = new CreateEntityConnection(QueryConnection.DbConnection, null);
var innerConnectionField = typeof(RelationalConnection).GetField("_connection", BindingFlags.NonPublic | BindingFlags.Instance);
var initalConnection = innerConnectionField.GetValue(QueryConnection);
innerConnectionField.SetValue(QueryConnection, new Microsoft.EntityFrameworkCore.Internal.LazyRef <DbConnection>(() => innerConnection));
RestoreConnection = () => innerConnectionField.SetValue(QueryConnection, initalConnection);
}
// CREATE query context
{
var relationalQueryContextType = typeof(RelationalQueryContext);
var relationalQueryContextConstructor = relationalQueryContextType.GetConstructors()[0];
// EF Core 1.1 preview
if (relationalQueryContextConstructor.GetParameters().Length == 5)
{
// REFLECTION: Query.Provider._queryCompiler._queryContextFactory.ExecutionStrategyFactory
var executionStrategyFactoryField = queryContextFactory.GetType().GetProperty("ExecutionStrategyFactory", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
var executionStrategyFactory = executionStrategyFactoryField.GetValue(queryContextFactory);
var lazyRefStateManager = new LazyRef <IStateManager>(() => stateManager);
queryContext = (RelationalQueryContext)relationalQueryContextConstructor.Invoke(new object[] { createQueryBufferDelegate, QueryConnection, lazyRefStateManager, concurrencyDetector, executionStrategyFactory });
}
else if (isEFCore2x)
{
// REFLECTION: Query.Provider._queryCompiler._queryContextFactory.ExecutionStrategyFactory
var executionStrategyFactoryField = queryContextFactory.GetType().GetProperty("ExecutionStrategyFactory", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
var executionStrategyFactory = executionStrategyFactoryField.GetValue(queryContextFactory);
var lazyRefStateManager = new LazyRef <IStateManager>(() => stateManager);
var dependenciesProperty3 = typeof(RelationalQueryContextFactory).GetProperty("Dependencies", BindingFlags.NonPublic | BindingFlags.Instance);
var dependencies3 = dependenciesProperty3.GetValue(queryContextFactory);
queryContext = (RelationalQueryContext)relationalQueryContextConstructor.Invoke(new object[] { dependencies3, createQueryBufferDelegate, QueryConnection, executionStrategyFactory });
}
else
{
queryContext = (RelationalQueryContext)relationalQueryContextConstructor.Invoke(new object[] { createQueryBufferDelegate, QueryConnection, stateManager, concurrencyDetector });
}
}
Expression newQuery;
if (isEFCore2x)
{
var parameterExtractingExpressionVisitorConstructors = typeof(ParameterExtractingExpressionVisitor).GetConstructors();
if (parameterExtractingExpressionVisitorConstructors.Any(x => x.GetParameters().Length == 5))
{
// EF Core 2.1
var parameterExtractingExpressionVisitorConstructor = parameterExtractingExpressionVisitorConstructors.First(x => x.GetParameters().Length == 5);
var parameterExtractingExpressionVisitor = (ParameterExtractingExpressionVisitor)parameterExtractingExpressionVisitorConstructor.Invoke(new object[] { evaluatableExpressionFilter, queryContext, logger, true, false });
// CREATE new query from query visitor
newQuery = parameterExtractingExpressionVisitor.ExtractParameters(Query.Expression);
}
else
{
var parameterExtractingExpressionVisitorConstructor = parameterExtractingExpressionVisitorConstructors.First(x => x.GetParameters().Length == 6);
ParameterExtractingExpressionVisitor parameterExtractingExpressionVisitor = null;
// EF Core 2.1
if (parameterExtractingExpressionVisitorConstructor.GetParameters().Where(x => x.ParameterType == typeof(DbContext)).Any())
{
parameterExtractingExpressionVisitor = (ParameterExtractingExpressionVisitor)parameterExtractingExpressionVisitorConstructor.Invoke(new object[] { evaluatableExpressionFilter, queryContext, logger, context, true, false });
}
else
{
parameterExtractingExpressionVisitor = (ParameterExtractingExpressionVisitor)parameterExtractingExpressionVisitorConstructor.Invoke(new object[] { evaluatableExpressionFilter, queryContext, logger, null, true, false });
}
// CREATE new query from query visitor
newQuery = parameterExtractingExpressionVisitor.ExtractParameters(Query.Expression);
}
}
else
{
// CREATE new query from query visitor
var extractParametersMethods = typeof(ParameterExtractingExpressionVisitor).GetMethod("ExtractParameters", BindingFlags.Public | BindingFlags.Static);
newQuery = (Expression)extractParametersMethods.Invoke(null, new object[] { Query.Expression, queryContext, evaluatableExpressionFilter, logger });
}
// PARSE new query
var queryModel = createQueryParser.GetParsedQuery(newQuery);
// CREATE query model visitor
var queryModelVisitor = (RelationalQueryModelVisitor)queryCompilationContextFactory.Create(false).CreateQueryModelVisitor();
// REFLECTION: Query.Provider._queryCompiler._database._queryCompilationContextFactory.Create(false).CreateQueryModelVisitor().CreateQueryExecutor()
var createQueryExecutorMethod = queryModelVisitor.GetType().GetMethod("CreateQueryExecutor");
var createQueryExecutorMethodGeneric = createQueryExecutorMethod.MakeGenericMethod(Query.ElementType);
var queryExecutor = createQueryExecutorMethodGeneric.Invoke(queryModelVisitor, new[] { queryModel });
// SET value
QueryExecutor = queryExecutor;
QueryContext = queryContext;
// RETURN the IRealationCommand
var sqlQuery = queryModelVisitor.Queries.First();
var relationalCommand = sqlQuery.CreateDefaultQuerySqlGenerator().GenerateSql(queryContext.ParameterValues);
return(relationalCommand);
}
/// <summary>
/// Creates a default <see cref="CompoundExpressionTreeProcessor"/> that already has the expression tree processing steps defined by the re-linq assembly
/// registered. Users can insert additional processing steps.
/// </summary>
/// <param name="tranformationProvider">
/// The tranformation provider to be used by the <see cref="TransformingExpressionTreeProcessor"/> included
/// in the result set. Use <see cref="ExpressionTransformerRegistry.CreateDefault"/> to create a default provider.
/// </param>
/// <param name="evaluatableExpressionFilter">
/// The expression filter used by the <see cref="PartialEvaluatingExpressionTreeProcessor"/> included in the result set.
/// Use <see langword="null" /> to indicate that no custom filtering should be applied.
/// </param>
/// <returns>
/// A default <see cref="CompoundExpressionTreeProcessor"/> that already has all expression tree processing steps defined by the re-linq assembly
/// registered.
/// </returns>
/// <remarks>
/// The following steps are included:
/// <list type="bullet">
/// <item><see cref="PartialEvaluatingExpressionTreeProcessor"/></item>
/// <item><see cref="TransformingExpressionTreeProcessor"/> (parameterized with <paramref name="tranformationProvider"/>)</item>
/// </list>
/// </remarks>
public static CompoundExpressionTreeProcessor CreateDefaultProcessor (
IExpressionTranformationProvider tranformationProvider,
IEvaluatableExpressionFilter evaluatableExpressionFilter = null)
{
ArgumentUtility.CheckNotNull ("tranformationProvider", tranformationProvider);
return new CompoundExpressionTreeProcessor (
new IExpressionTreeProcessor[]
{
new PartialEvaluatingExpressionTreeProcessor (evaluatableExpressionFilter ?? new NullEvaluatableExpressionFilter()),
new TransformingExpressionTreeProcessor (tranformationProvider)
});
}
protected EvaluatableTreeFindingExpressionVisitor(IEvaluatableExpressionFilter evaluatableExpressionFilter)
{
EvaluatableExpressionFilter = evaluatableExpressionFilter;
}
protected NhEvaluatableTreeFindingExpressionVisitor(IEvaluatableExpressionFilter evaluatableExpressionFilter)
: base(evaluatableExpressionFilter)
{
}
