public SelectExpression([NotNull] IQuerySqlGeneratorFactory querySqlGeneratorFactory)
: base(null, null)
{
Check.NotNull(querySqlGeneratorFactory, nameof(querySqlGeneratorFactory));
_querySqlGeneratorFactory = querySqlGeneratorFactory;
}
public QueryingEnumerable(
CosmosQueryContext cosmosQueryContext,
ISqlExpressionFactory sqlExpressionFactory,
IQuerySqlGeneratorFactory querySqlGeneratorFactory,
SelectExpression selectExpression,
Func <CosmosQueryContext, JObject, T> shaper,
Type contextType,
string partitionKeyFromExtension,
bool performIdentityResolution)
{
_cosmosQueryContext = cosmosQueryContext;
_sqlExpressionFactory = sqlExpressionFactory;
_querySqlGeneratorFactory = querySqlGeneratorFactory;
_selectExpression = selectExpression;
_shaper = shaper;
_contextType = contextType;
_queryLogger = cosmosQueryContext.QueryLogger;
_performIdentityResolution = performIdentityResolution;
var partitionKey = selectExpression.GetPartitionKey(cosmosQueryContext.ParameterValues);
if (partitionKey != null && partitionKeyFromExtension != null && partitionKeyFromExtension != partitionKey)
{
throw new InvalidOperationException(CosmosStrings.PartitionKeyMismatch(partitionKeyFromExtension, partitionKey));
}
_partitionKey = partitionKey ?? partitionKeyFromExtension;
}
/// <summary>
/// From IncludeExpressionVisitor in EF core
/// </summary>
public ReplaceIncludeExpressionVisitor(
ISelectExpressionFactory selectExpressionFactory,
ICompositePredicateExpressionVisitorFactory compositePredicateExpressionVisitorFactory,
IMaterializerFactory materializerFactory,
IShaperCommandContextFactory shaperCommandContextFactory,
IRelationalAnnotationProvider relationalAnnotationProvider,
IQuerySqlGeneratorFactory querySqlGeneratorFactory,
IQuerySource querySource,
IReadOnlyList <INavigation> navigationPath,
RelationalQueryCompilationContext queryCompilationContext,
IReadOnlyList <int> queryIndexes,
bool querySourceRequiresTracking,
INavigationExpressionCollection collection)
{
_selectExpressionFactory = selectExpressionFactory;
_compositePredicateExpressionVisitorFactory = compositePredicateExpressionVisitorFactory;
_materializerFactory = materializerFactory;
_shaperCommandContextFactory = shaperCommandContextFactory;
_relationalAnnotationProvider = relationalAnnotationProvider;
_querySqlGeneratorFactory = querySqlGeneratorFactory;
_querySource = querySource;
_navigationPath = navigationPath;
_queryCompilationContext = queryCompilationContext;
_queryIndexes = queryIndexes;
_querySourceRequiresTracking = querySourceRequiresTracking;
_collection = collection;
}
/// <summary>
/// Clones this dependency parameter object with one service replaced.
/// </summary>
/// <param name="querySqlGeneratorFactory"> A replacement for the current dependency of this type. </param>
/// <returns> A new parameter object with the given service replaced. </returns>
public RelationalShapedQueryCompilingExpressionVisitorDependencies With(
[NotNull] IQuerySqlGeneratorFactory querySqlGeneratorFactory)
=> new RelationalShapedQueryCompilingExpressionVisitorDependencies(
querySqlGeneratorFactory,
SqlExpressionFactory,
ParameterNameGeneratorFactory,
RelationalParameterBasedQueryTranslationPostprocessorFactory);
/// <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>
public CosmosShapedQueryCompilingExpressionVisitorFactory(IEntityMaterializerSource entityMaterializerSource,
ISqlExpressionFactory sqlExpressionFactory,
IQuerySqlGeneratorFactory querySqlGeneratorFactory)
{
_entityMaterializerSource = entityMaterializerSource;
_sqlExpressionFactory = sqlExpressionFactory;
_querySqlGeneratorFactory = querySqlGeneratorFactory;
}
/// <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>
public CosmosShapedQueryCompilingExpressionVisitorFactory(
[NotNull] ShapedQueryCompilingExpressionVisitorDependencies dependencies,
[NotNull] ISqlExpressionFactory sqlExpressionFactory,
[NotNull] IQuerySqlGeneratorFactory querySqlGeneratorFactory)
{
_dependencies = dependencies;
_sqlExpressionFactory = sqlExpressionFactory;
_querySqlGeneratorFactory = querySqlGeneratorFactory;
}
/// <summary>
/// <para>
/// Creates the service dependencies parameter object for a <see cref="SelectExpression" />.
/// </para>
/// <para>
/// Do not call this constructor directly from either provider or application code as it may change
/// as new dependencies are added. Instead, use this type in your constructor so that an instance
/// will be created and injected automatically by the dependency injection container. To create
/// an instance with some dependent services replaced, first resolve the object from the dependency
/// injection container, then replace selected services using the 'With...' methods. Do not call
/// the constructor at any point in this process.
/// </para>
/// </summary>
/// <param name="querySqlGeneratorFactory"> The query SQL generator factory. </param>
/// <param name="relationalAnnotationProvider"></param>
public SelectExpressionDependencies([NotNull] IQuerySqlGeneratorFactory querySqlGeneratorFactory,
[NotNull] IRelationalAnnotationProvider relationalAnnotationProvider)
{
Check.NotNull(querySqlGeneratorFactory, nameof(querySqlGeneratorFactory));
Check.NotNull(relationalAnnotationProvider, nameof(relationalAnnotationProvider));
QuerySqlGeneratorFactory = querySqlGeneratorFactory;
RelationalAnnotationProvider = relationalAnnotationProvider;
}
public SelectExpression(
[NotNull] IQuerySqlGeneratorFactory querySqlGeneratorFactory,
[NotNull] string alias)
: base(null, Check.NotNull(alias, nameof(alias)))
{
Check.NotNull(querySqlGeneratorFactory, nameof(querySqlGeneratorFactory));
_querySqlGeneratorFactory = querySqlGeneratorFactory;
}
public MongoShapedQueryCompilingExpressionVisitorFactory(
ShapedQueryCompilingExpressionVisitorDependencies dependencies,
ISqlExpressionFactory sqlExpressionFactory,
IQuerySqlGeneratorFactory querySqlGeneratorFactory)
{
_dependencies = dependencies;
_sqlExpressionFactory = sqlExpressionFactory;
_querySqlGeneratorFactory = querySqlGeneratorFactory;
}
/// <summary>
/// 将linq转换成sql 返回sql和参数(EFCore 3.1)
/// 第一个字符串为替换过 参数的sql字符串
/// 第二个字符串为原始的sql字符串
/// 第三个参数为参数
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
public static (string, string, IReadOnlyDictionary <string, object>) ToSqlWithParams <TEntity>(this IQueryable <TEntity> query)
{
var enumerator = query.Provider
.Execute <IEnumerable <TEntity> >(query.Expression)
.GetEnumerator();
Type enumeratorType = enumerator.GetType();
FieldInfo relationalCommandCacheFieldInfo = enumeratorType.GetField("_relationalCommandCache", bindingFlags)
?? throw new InvalidOperationException(
$"cannot find field _relationalCommandCache on type {enumeratorType.Name}");
Type relationalCommandCacheType = relationalCommandCacheFieldInfo.FieldType;
//获取查询表达式
var selectFieldInfo = relationalCommandCacheType.GetField("_selectExpression", bindingFlags)
?? throw new InvalidOperationException(
$"cannot find field _selectExpression on type {relationalCommandCacheType.Name}");
var sqlGeneratorFieldInfo = relationalCommandCacheType.GetField("_querySqlGeneratorFactory", bindingFlags)
?? throw new InvalidOperationException(
$"cannot find field _querySqlGeneratorFactory on type {relationalCommandCacheType.Name}");
var queryContextFieldInfo = enumeratorType.GetField("_relationalQueryContext", bindingFlags)
?? throw new InvalidOperationException(
$"cannot find field _relationalQueryContext on type {enumeratorType.Name}");
object relationalCommandCache = relationalCommandCacheFieldInfo.GetValue(enumerator);
var selectExpression = selectFieldInfo.GetValue(relationalCommandCache) as SelectExpression
?? throw new InvalidOperationException($"could not get SelectExpression");
var queryContext = queryContextFieldInfo.GetValue(enumerator) as RelationalQueryContext
?? throw new InvalidOperationException($"could not get RelationalQueryContext");
IQuerySqlGeneratorFactory factory = sqlGeneratorFieldInfo.GetValue(relationalCommandCache)
as IQuerySqlGeneratorFactory
?? throw new InvalidOperationException($"could not get IQuerySqlGeneratorFactory");
//创建一个查询的对象
var sqlGenerator = factory.Create();
//获取执行的命令
var command = sqlGenerator.GetCommand(selectExpression);
//执行sql传递的参数
var parametersDict = queryContext.ParameterValues;
//原始的sql执行文本
var sql = command.CommandText;
//将参数赋值转换
var converSql = sql;
if (parametersDict != null && parametersDict.Count() > 0)
{
foreach (var item in parametersDict)
{
converSql = converSql.Replace($"@{item.Key}", $"'{item.Value.ToString()}'");
}
}
return(converSql, sql, parametersDict);
}
/// <summary>
/// <para>
/// Creates the service dependencies parameter object for a <see cref="SelectExpression" />.
/// </para>
/// <para>
/// Do not call this constructor directly from either provider or application code as it may change
/// as new dependencies are added. Instead, use this type in your constructor so that an instance
/// will be created and injected automatically by the dependency injection container. To create
/// an instance with some dependent services replaced, first resolve the object from the dependency
/// injection container, then replace selected services using the 'With...' methods. Do not call
/// the constructor at any point in this process.
/// </para>
/// </summary>
/// <param name="querySqlGeneratorFactory"> The query SQL generator factory. </param>
/// <param name="typeMapper"> The type mapper. </param>
public SelectExpressionDependencies(
[NotNull] IQuerySqlGeneratorFactory querySqlGeneratorFactory,
[NotNull] IRelationalTypeMapper typeMapper)
{
Check.NotNull(querySqlGeneratorFactory, nameof(querySqlGeneratorFactory));
Check.NotNull(typeMapper, nameof(typeMapper));
QuerySqlGeneratorFactory = querySqlGeneratorFactory;
TypeMapper = typeMapper;
}
public static IRelationalCommand Generate(
this DbContext dbContext,
SelectExpression databaseExpression,
IReadOnlyDictionary <string, object> parameters = null)
{
IQuerySqlGeneratorFactory sqlGeneratorFactory = dbContext.GetService <IQuerySqlGeneratorFactory>();
IQuerySqlGenerator sqlGenerator = sqlGeneratorFactory.CreateDefault(databaseExpression);
return(sqlGenerator.GenerateSql(parameters ?? new Dictionary <string, object>()));
}
/// <summary>
/// <para>
/// Creates the service dependencies parameter object for a <see cref="SelectExpression" />.
/// </para>
/// <para>
/// Do not call this constructor directly from either provider or application code as it may change
/// as new dependencies are added. Instead, use this type in your constructor so that an instance
/// will be created and injected automatically by the dependency injection container. To create
/// an instance with some dependent services replaced, first resolve the object from the dependency
/// injection container, then replace selected services using the 'With...' methods. Do not call
/// the constructor at any point in this process.
/// </para>
/// </summary>
/// <param name="querySqlGeneratorFactory"> The query SQL generator factory. </param>
/// <param name="typeMappingSource"> The type mapper. </param>
public SelectExpressionDependencies(
[NotNull] IQuerySqlGeneratorFactory querySqlGeneratorFactory,
[NotNull] IRelationalTypeMappingSource typeMappingSource)
{
Check.NotNull(querySqlGeneratorFactory, nameof(querySqlGeneratorFactory));
Check.NotNull(typeMappingSource, nameof(typeMappingSource));
QuerySqlGeneratorFactory = querySqlGeneratorFactory;
TypeMappingSource = typeMappingSource;
}
public SelectExpression([NotNull] IQuerySqlGeneratorFactory querySqlGeneratorFactory,
[NotNull] RelationalQueryCompilationContext queryCompilationContext)
: base(null, null)
{
Check.NotNull(querySqlGeneratorFactory, nameof(querySqlGeneratorFactory));
Check.NotNull(queryCompilationContext, nameof(queryCompilationContext));
_querySqlGeneratorFactory = querySqlGeneratorFactory;
_queryCompilationContext = queryCompilationContext;
}
public Enumerator(QueryingEnumerable <T> queryingEnumerable)
{
_relationalQueryContext = queryingEnumerable._relationalQueryContext;
_shaper = queryingEnumerable._shaper;
_selectExpression = queryingEnumerable._selectExpression;
_querySqlGeneratorFactory = queryingEnumerable._querySqlGeneratorFactory;
_contextType = queryingEnumerable._contextType;
_logger = queryingEnumerable._logger;
_sqlExpressionFactory = queryingEnumerable._sqlExpressionFactory;
_parameterNameGeneratorFactory = queryingEnumerable._parameterNameGeneratorFactory;
}
/// <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>
public CosmosShapedQueryCompilingExpressionVisitor(
ShapedQueryCompilingExpressionVisitorDependencies dependencies,
QueryCompilationContext queryCompilationContext,
ISqlExpressionFactory sqlExpressionFactory,
IQuerySqlGeneratorFactory querySqlGeneratorFactory)
: base(dependencies, queryCompilationContext)
{
_sqlExpressionFactory = sqlExpressionFactory;
_querySqlGeneratorFactory = querySqlGeneratorFactory;
_contextType = queryCompilationContext.ContextType;
_logger = queryCompilationContext.Logger;
}
/// <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>
public RelationalCommandCache(
[NotNull] IMemoryCache memoryCache,
[NotNull] IQuerySqlGeneratorFactory querySqlGeneratorFactory,
[NotNull] IRelationalParameterBasedSqlProcessorFactory relationalParameterBasedSqlProcessorFactory,
bool useRelationalNulls,
[NotNull] SelectExpression selectExpression)
{
_memoryCache = memoryCache;
_querySqlGeneratorFactory = querySqlGeneratorFactory;
_selectExpression = selectExpression;
_relationalParameterBasedSqlProcessor = relationalParameterBasedSqlProcessorFactory.Create(useRelationalNulls);
}
/// <summary>
/// parse select statement of queryable
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="queryable"></param>
/// <param name="ctx"></param>
/// <returns></returns>
public static SelectParsingResult Parse <TEntity>(this IQueryable <TEntity> queryable, DbContext ctx, bool ignoreQueryFilters) where TEntity : class
{
if (ignoreQueryFilters)
{
queryable = queryable.IgnoreQueryFilters();
}
SelectParsingResult parsingResult = new SelectParsingResult();
Expression query = queryable.Expression;
var databaseDependencies = ctx.GetService <DatabaseDependencies>();
IQueryTranslationPreprocessorFactory _queryTranslationPreprocessorFactory = ctx.GetService <IQueryTranslationPreprocessorFactory>();
IQueryableMethodTranslatingExpressionVisitorFactory _queryableMethodTranslatingExpressionVisitorFactory = ctx.GetService <IQueryableMethodTranslatingExpressionVisitorFactory>();
IQueryTranslationPostprocessorFactory _queryTranslationPostprocessorFactory = ctx.GetService <IQueryTranslationPostprocessorFactory>();
QueryCompilationContext queryCompilationContext = databaseDependencies.QueryCompilationContextFactory.Create(true);
IDiagnosticsLogger <DbLoggerCategory.Query> logger = ctx.GetService <IDiagnosticsLogger <DbLoggerCategory.Query> >();
QueryContext queryContext = ctx.GetService <IQueryContextFactory>().Create();
QueryCompiler queryComipler = ctx.GetService <IQueryCompiler>() as QueryCompiler;
//parameterize determines if it will use "Declare" or not
MethodCallExpression methodCallExpr1 = queryComipler.ExtractParameters(query, queryContext, logger, parameterize: true) as MethodCallExpression;
QueryTranslationPreprocessor queryTranslationPreprocessor = _queryTranslationPreprocessorFactory.Create(queryCompilationContext);
MethodCallExpression methodCallExpr2 = queryTranslationPreprocessor.Process(methodCallExpr1) as MethodCallExpression;
QueryableMethodTranslatingExpressionVisitor queryableMethodTranslatingExpressionVisitor =
_queryableMethodTranslatingExpressionVisitorFactory.Create(queryCompilationContext);
ShapedQueryExpression shapedQueryExpression1 = queryableMethodTranslatingExpressionVisitor.Visit(methodCallExpr2) as ShapedQueryExpression;
QueryTranslationPostprocessor queryTranslationPostprocessor = _queryTranslationPostprocessorFactory.Create(queryCompilationContext);
ShapedQueryExpression shapedQueryExpression2 = queryTranslationPostprocessor.Process(shapedQueryExpression1) as ShapedQueryExpression;
IRelationalParameterBasedSqlProcessorFactory _relationalParameterBasedSqlProcessorFactory =
ctx.GetService <IRelationalParameterBasedSqlProcessorFactory>();
RelationalParameterBasedSqlProcessor _relationalParameterBasedSqlProcessor = _relationalParameterBasedSqlProcessorFactory.Create(true);
SelectExpression selectExpression = (SelectExpression)shapedQueryExpression2.QueryExpression;
selectExpression = _relationalParameterBasedSqlProcessor.Optimize(selectExpression, queryContext.ParameterValues, out bool canCache);
IQuerySqlGeneratorFactory querySqlGeneratorFactory = ctx.GetService <IQuerySqlGeneratorFactory>();
IZackQuerySqlGenerator querySqlGenerator = querySqlGeneratorFactory.Create() as IZackQuerySqlGenerator;
if (querySqlGenerator == null)
{
throw new InvalidOperationException("please add dbContext.UseBatchEF() to OnConfiguring first!");
}
querySqlGenerator.IsForBatchEF = true;
querySqlGenerator.GetCommand(selectExpression);
parsingResult.Parameters = queryContext.ParameterValues;
parsingResult.PredicateSQL = querySqlGenerator.PredicateSQL;
parsingResult.ProjectionSQL = querySqlGenerator.ProjectionSQL;
TableExpression tableExpression = selectExpression.Tables[0] as TableExpression;
parsingResult.TableName = tableExpression.Table.Name;
return(parsingResult);
}
public CosmosShapedQueryCompilingExpressionVisitor(
ShapedQueryCompilingExpressionVisitorDependencies dependencies,
CosmosQueryCompilationContext cosmosQueryCompilationContext,
ISqlExpressionFactory sqlExpressionFactory,
IQuerySqlGeneratorFactory querySqlGeneratorFactory)
: base(dependencies, cosmosQueryCompilationContext)
{
_sqlExpressionFactory = sqlExpressionFactory;
_querySqlGeneratorFactory = querySqlGeneratorFactory;
_contextType = cosmosQueryCompilationContext.ContextType;
_threadSafetyChecksEnabled = dependencies.CoreSingletonOptions.AreThreadSafetyChecksEnabled;
_partitionKeyFromExtension = cosmosQueryCompilationContext.PartitionKeyFromExtension;
}
/// <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>
public IncludeExpressionVisitorFactory(
[NotNull] ISelectExpressionFactory selectExpressionFactory,
[NotNull] ICompositePredicateExpressionVisitorFactory compositePredicateExpressionVisitorFactory,
[NotNull] IMaterializerFactory materializerFactory,
[NotNull] IShaperCommandContextFactory shaperCommandContextFactory,
[NotNull] IRelationalAnnotationProvider relationalAnnotationProvider,
[NotNull] IQuerySqlGeneratorFactory querySqlGeneratorFactory)
{
Check.NotNull(selectExpressionFactory, nameof(selectExpressionFactory));
Check.NotNull(compositePredicateExpressionVisitorFactory, nameof(compositePredicateExpressionVisitorFactory));
Check.NotNull(materializerFactory, nameof(materializerFactory));
Check.NotNull(shaperCommandContextFactory, nameof(shaperCommandContextFactory));
Check.NotNull(relationalAnnotationProvider, nameof(relationalAnnotationProvider));
Check.NotNull(querySqlGeneratorFactory, nameof(querySqlGeneratorFactory));
_selectExpressionFactory = selectExpressionFactory;
_compositePredicateExpressionVisitorFactory = compositePredicateExpressionVisitorFactory;
_materializerFactory = materializerFactory;
_shaperCommandContextFactory = shaperCommandContextFactory;
_relationalAnnotationProvider = relationalAnnotationProvider;
_querySqlGeneratorFactory = querySqlGeneratorFactory;
}
/// <summary>
/// Initializes a new instance of the Microsoft.EntityFrameworkCore.Query.Expressions.SelectExpressionFactory class.
/// </summary>
/// <param name="querySqlGeneratorFactory"> The query SQL generator factory. </param>
public SelectExpressionFactory([NotNull] IQuerySqlGeneratorFactory querySqlGeneratorFactory)
{
Check.NotNull(querySqlGeneratorFactory, nameof(querySqlGeneratorFactory));
_querySqlGeneratorFactory = querySqlGeneratorFactory;
}
