public EntityQueryProvider([NotNull] IQueryCompiler queryCompiler)
{
_queryCompiler = queryCompiler;
_genericExecuteMethod = queryCompiler.GetType()
.GetRuntimeMethods()
.Single(m => (m.Name == "Execute") && m.IsGenericMethod);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// 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>
protected override Func <QueryContext, AsyncEnumerable <TResult> > CreateCompiledQuery(
IQueryCompiler queryCompiler, Expression expression)
{
var compiledQuery = queryCompiler.CreateCompiledAsyncQuery <IAsyncEnumerable <TResult> >(expression);
return(qc => new AsyncEnumerable <TResult>(compiledQuery(qc)));
}
protected BaseOperation(IQuery query, BooleanOperationType type)
{
_query = query;
OperationType = type;
// the compiler will build our query-dsl. switch it out to custom impl if you wish to build your own query service
_compiler = new DefaultQueryCompiler();
}
public ImagesComponent(
IEditor editor,
IExplorer explorer,
IPresentation presentation,
IFileSystemErrorView dialogView,
ISelection selection,
IEntityManager entityManager,
IClipboardService clipboard,
IQueryHistory state,
IQueryFactory queryFactory,
IQueryCompiler queryCompiler,
IQueryEvaluatorFactory queryEvaluatorFactory)
{
_editor = editor;
_explorer = explorer;
_presentation = presentation;
_dialogView = dialogView;
_selection = selection;
_entityManager = entityManager;
_clipboard = clipboard;
_queryHistory = state;
_queryFactory = queryFactory;
_queryCompiler = queryCompiler;
_queryEvaluatorFactory = queryEvaluatorFactory;
}
public ExecutionKernel(IQueryCompiler compiler, IExecutionContext executionContext)
{
_compiler = compiler;
_executionContext = executionContext;
_mapper = new ObjectMapper(new Settings());
}
private static IQueryParser GetQueryParser(IQueryCompiler queryCompiler) =>
(IQueryParser)CreateQueryParserMethod.Value.Invoke(
queryCompiler,
new[]
{
NodeTypeProviderField.Value.GetValue(queryCompiler)
}
);
public TheCompileRuleMethodTests()
{
_queryCompiler = new QueryCompiler <QueryTestClass>();
_testData = new List <QueryTestClass>
{
new QueryTestClass(5, "mere"),
new QueryTestClass(10, "pere"),
new QueryTestClass(20, "banane")
};
}
public QueryKeyGenerator(IQueryContextFactory queryContextFactory, IQueryCompiler queryCompiler, IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
if (queryCompiler is not QueryCompiler compiler)
{
throw new InvalidCastException($"Implementation type of '{nameof(IQueryCompiler)}' must be '{typeof(QueryCompiler)}'");
}
_queryCompiler = compiler;
_queryContextFactory = queryContextFactory;
_logger = logger;
}
public CachingQueryProvider(
IDbCache cache,
IQueryKeyGenerator queryKeyGenerator,
IQueryCompiler queryCompiler,
ICurrentDbContext currentContext,
IDbContextOptions options,
IDiagnosticsLogger <DbLoggerCategory.Query> logger)
: base(queryCompiler)
{
_cache = cache;
_queryKeyGenerator = queryKeyGenerator;
_currentContext = currentContext;
_extension = options.FindExtension <CachingOptionsExtension>();
_logger = logger.Logger;
}
public Editor(
IFileSystem fileSystem,
IFileSystemErrorView dialogView,
IQueryHistory queryHistory,
IQueryCompiler queryCompiler,
IQueryErrorListener queryErrorListener,
IQuerySuggestions querySuggestions)
{
_fileSystem = fileSystem;
_dialogView = dialogView;
_queryHistory = queryHistory;
_queryCompiler = queryCompiler;
_queryErrorListener = queryErrorListener;
_querySuggestions = querySuggestions;
}
public DefaultDatabaseEngine(
IDatabaseComponentFactory databaseEngineFactory,
IDatabase database)
{
this.compiler = databaseEngineFactory.CreateQueryCompiler();
this.executor = databaseEngineFactory.CreateQueryExecutor();
this.concurrencyManager = databaseEngineFactory.CreateConcurrencyManager();
this.transactionHandler = databaseEngineFactory.CreateTransactionHandler();
this.loggingPort = databaseEngineFactory.CreateLoggingPort();
this.serviceProvider = databaseEngineFactory.CreateServiceProvider();
foreach (IDatabaseComponent component in
this.Components.OfType<IDatabaseComponent>())
{
component.Initialize(database);
}
}
public DefaultDatabaseEngine(
IDatabaseComponentFactory databaseEngineFactory,
IDatabase database)
{
this.compiler = databaseEngineFactory.CreateQueryCompiler();
this.executor = databaseEngineFactory.CreateQueryExecutor();
this.concurrencyManager = databaseEngineFactory.CreateConcurrencyManager();
this.transactionHandler = databaseEngineFactory.CreateTransactionHandler();
this.loggingPort = databaseEngineFactory.CreateLoggingPort();
this.serviceProvider = databaseEngineFactory.CreateServiceProvider();
foreach (IDatabaseComponent component in
this.Components.OfType <IDatabaseComponent>())
{
component.Initialize(database);
}
}
public static string ToSql <TEntity>(this IQueryable <TEntity> queryable)
where TEntity : class
{
if (!(queryable is EntityQueryable <TEntity>) && !(queryable is InternalDbSet <TEntity>))
{
throw new ArgumentException();
}
IQueryCompiler queryCompiler = (IQueryCompiler)_queryCompilerField.GetValue(queryable.Provider);
IQueryModelGenerator queryModelGenerator = (IQueryModelGenerator)_queryModelGeneratorField.GetValue(queryCompiler);
QueryModel queryModel = queryModelGenerator.ParseQuery(queryable.Expression);
object database = _databaseField.GetValue(queryCompiler);
IQueryCompilationContextFactory queryCompilationContextFactory = ((DatabaseDependencies)_dependenciesProperty.GetValue(database)).QueryCompilationContextFactory;
QueryCompilationContext queryCompilationContext = queryCompilationContextFactory.Create(false);
RelationalQueryModelVisitor modelVisitor = (RelationalQueryModelVisitor)queryCompilationContext.CreateQueryModelVisitor();
modelVisitor.CreateQueryExecutor <TEntity>(queryModel);
return(modelVisitor.Queries.Join(Environment.NewLine + Environment.NewLine));
}
private static string getExpressionKeyHash(
IQueryCompiler queryCompiler,
IQueryModelGenerator queryModelGenerator,
IEFCacheKeyHashProvider cacheKeyHashProvider,
Expression expression)
{
var queryContextFactory = (IQueryContextFactory)_queryContextFactoryField.GetValue(queryCompiler);
var queryContext = queryContextFactory.Create();
var logger = (IDiagnosticsLogger <DbLoggerCategory.Query>)_loggerField.GetValue(queryCompiler);
expression = queryModelGenerator.ExtractParameters(logger, expression, queryContext);
var expressionKey = $"{ExpressionEqualityComparer.Instance.GetHashCode(expression)};";
var parameterValues = queryContext.ParameterValues;
if (parameterValues.Any())
{
expressionKey = parameterValues.Aggregate(expressionKey, (current, item) => current + $"{item.Key}={item.Value?.GetHashCode()};");
}
return(cacheKeyHashProvider.ComputeHash(expressionKey));
}
public QueryEditorPresenter(
IQueryEditorView view,
IFileSystemErrorView dialogErrorView,
IQueryHistory appHistory,
IQueryCompiler queryCompiler,
IQueryErrorListener queryErrorListener,
IQuerySuggestions querySuggestions,
IEditor editor)
{
View = view;
_dialogErrorView = dialogErrorView;
_queryCompiler = queryCompiler;
_queryErrorListener = queryErrorListener;
_querySuggestions = querySuggestions;
_appHistory = appHistory;
_editor = editor;
SubscribeTo(View, "View");
_queryCompiler.Views.Changed += QueryViewsOnChanged;
UpdateViews();
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// 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>
protected abstract Func <QueryContext, TResult> CreateCompiledQuery(
[NotNull] IQueryCompiler queryCompiler, [NotNull] Expression expression);
/// <summary>
///填充实例，存储实例，查询实例
/// </summary>
/// <param name="fill"></param>
/// <param name="saveCompiler"></param>
/// <param name="findCompiler"></param>
public SqlServerCompiler(IFill fill, ISaveCompiler saveCompiler, IQueryCompiler findCompiler)
: base(fill, saveCompiler, findCompiler)
{
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// 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>
protected override Func <QueryContext, Task <TResult> > CreateCompiledQuery(
IQueryCompiler queryCompiler, Expression expression)
=> queryCompiler.CreateCompiledAsyncSingletonQuery <TResult>(expression);
public QueryProvider(IQueryCompiler queryCompiler) : base(queryCompiler)
{
}
public QueryBuilder(IQueryCompiler <T> queryCompiler)
{
_queryCompiler = queryCompiler;
}
/// <inheritdoc />
protected override Func <QueryContext, IAsyncEnumerable <TResult> > CreateCompiledQuery(
IQueryCompiler queryCompiler, Expression expression)
=> queryCompiler.CreateCompiledAsyncQuery <IAsyncEnumerable <TResult> >(expression);
public DatabaseConnection(IQueryCompiler compiler, IExecutionContext executionContext)
{
_compiler = compiler;
_executionContext = executionContext;
}
public object Execute(IQueryCompiler compiler, Type type, params Value[] parameters)
{
return(compiler.Execute(type, this, parameters));
}
/// <summary>
///填充实例，存储实例，查询实例
/// </summary>
/// <param name="fill"></param>
/// <param name="save"></param>
/// <param name="queryCompiler"></param>
protected CompilerBase(IFill fill, ISaveCompiler save, IQueryCompiler queryCompiler)
{
Fill = fill;
SaveCompiler = save;
QueryCompiler = queryCompiler;
}
public IEnumerable <string[]> Execute(IQueryCompiler compiler, params Value[] parameters)
{
return(compiler.Execute(this, parameters));
}
public IPreparedStatement Prepare(IQueryCompiler compiler)
{
return(compiler.Prepare(this));
}
public bool Execute(IQueryCompiler compiler, out int rowsAltered, params Value[] parameters)
{
return(compiler.Execute(this, out rowsAltered, parameters));
}
public GraphQLQueryProvider(IQueryCompiler queryCompiler)
{
_queryCompiler = queryCompiler ?? throw new ArgumentNullException(nameof(queryCompiler));
}
public MyEntityQueryProvider(IQueryCompiler queryCompiler) : base(queryCompiler)
{
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
protected override Func <QueryContext, TResult> CreateCompiledQuery(
IQueryCompiler queryCompiler, Expression expression)
=> queryCompiler.CreateCompiledQuery <TResult>(expression);
public EntityQueryProvider([NotNull] IQueryCompiler queryCompiler)
{
_queryCompiler = queryCompiler;
}
