/// <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 static Expression VisitSelect(IZackQuerySqlGenerator sqlGenerator, ISqlGenerationHelper _sqlGenerationHelper, SelectExpression selectExpression)
{
if (BatchUtils.IsNonComposedSetOperation(selectExpression))
{
sqlGenerator.P_GenerateSetOperation((SetOperationBase)selectExpression.Tables[0]);
return(selectExpression);
}
IRelationalCommandBuilder Sql = sqlGenerator.P_Sql;
IDisposable disposable = null;
if (selectExpression.Alias != null)
{
Sql.AppendLine("(");
disposable = sqlGenerator.P_Sql.Indent();
}
Sql.Append("SELECT ");
if (selectExpression.IsDistinct)
{
Sql.Append("DISTINCT ");
}
sqlGenerator.P_GenerateTop(selectExpression);
if (selectExpression.Projection.Any())
{
BatchUtils.GenerateList(selectExpression.Projection, Sql, delegate(ProjectionExpression e)
{
var oldSQL = Sql.Build().CommandText; //zack's code
sqlGenerator.Visit(e);
string column = BatchUtils.Diff(oldSQL, Sql.Build().CommandText); //zack's code
sqlGenerator.ProjectionSQL.Add(column); //zack's code
});
}
else
{
Sql.Append("1");
sqlGenerator.ProjectionSQL.Add("1"); //zack's code
}
if (selectExpression.Tables.Any())
{
Sql.AppendLine().Append("FROM ");
BatchUtils.GenerateList(selectExpression.Tables, Sql, delegate(TableExpressionBase e)
{
sqlGenerator.Visit(e);
}, delegate(IRelationalCommandBuilder sql)
{
sql.AppendLine();
});
}
else
{
sqlGenerator.P_GeneratePseudoFromClause();
}
if (selectExpression.Predicate != null)
{
Sql.AppendLine().Append("WHERE ");
var oldSQL = Sql.Build().CommandText; //zack's code
sqlGenerator.Visit(selectExpression.Predicate);
sqlGenerator.PredicateSQL = BatchUtils.Diff(oldSQL, Sql.Build().CommandText); //zack's code
}
if (selectExpression.GroupBy.Count > 0)
{
Sql.AppendLine().Append("GROUP BY ");
BatchUtils.GenerateList(selectExpression.GroupBy, Sql, delegate(SqlExpression e)
{
sqlGenerator.Visit(e);
});
}
if (selectExpression.Having != null)
{
Sql.AppendLine().Append("HAVING ");
sqlGenerator.Visit(selectExpression.Having);
}
sqlGenerator.P_GenerateOrderings(selectExpression);
sqlGenerator.P_GenerateLimitOffset(selectExpression);
if (selectExpression.Alias != null)
{
disposable.Dispose();
Sql.AppendLine().Append(")" + sqlGenerator.P_AliasSeparator + _sqlGenerationHelper.DelimitIdentifier(selectExpression.Alias));
}
return(selectExpression);
}
