public SubQueryExpression (QueryModel queryModel)
{
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
QueryModel = queryModel;
_type = queryModel.GetOutputDataInfo().DataType;
}
private OrderByClause GetOrderByClause (QueryModel queryModel)
{
if (queryModel.BodyClauses.Count == 0)
return null;
else
return queryModel.BodyClauses[queryModel.BodyClauses.Count - 1] as OrderByClause;
}
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
foreach (Ordering ordering in orderByClause.Orderings)
{
ordering.Expression = JoinReplacer(queryModel, ordering.Expression);
}
}
private void FlattenSubQuery(SubQueryExpression subQueryExpression, MainFromClause fromClause,
QueryModel queryModel)
{
// Create a new client-side select for the outer
// TODO - don't like calling GetGenericArguments here...
var clientSideSelect = new ClientSideSelect(new NonAggregatingGroupBySelectRewriter().Visit(queryModel.SelectClause.Selector, subQueryExpression.Type.GetGenericArguments()[0], queryModel.MainFromClause));
// Replace the outer select clause...
queryModel.SelectClause = subQueryExpression.QueryModel.SelectClause;
MainFromClause innerMainFromClause = subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(innerMainFromClause, fromClause);
foreach (var bodyClause in subQueryExpression.QueryModel.BodyClauses)
{
queryModel.BodyClauses.Add(bodyClause);
}
// Move the result operator up
if (queryModel.ResultOperators.Count != 0)
{
throw new NotImplementedException();
}
queryModel.ResultOperators.Add(new NonAggregatingGroupBy((GroupResultOperator) subQueryExpression.QueryModel.ResultOperators[0]));
queryModel.ResultOperators.Add(clientSideSelect);
}
public void SetUp ()
{
_mainFromClause = ExpressionHelper.CreateMainFromClause_Int();
_selectClause = ExpressionHelper.CreateSelectClause();
_queryModel = new QueryModel (_mainFromClause, _selectClause);
_querySourceMapping = new QuerySourceMapping();
}
/// <summary>
/// 将一组key=value添加入QueryModel.Items
/// </summary>
/// <param name="model">QueryModel</param>
/// <param name="key">当前项的HtmlName</param>
/// <param name="val">当前项的值</param>
public static void AddSearchItem(QueryModel model, string key, string val)
{
string field = "", prefix = "", orGroup = "", method = "";
var keywords = key.Split(']', ')', '}');
//将Html中的name分割为我们想要的几个部分
foreach (var keyword in keywords)
{
if (Char.IsLetterOrDigit(keyword[0])) field = keyword;
var last = keyword.Substring(1);
if (keyword[0] == '(') prefix = last;
if (keyword[0] == '[') method = last;
if (keyword[0] == '{') orGroup = last;
}
if (string.IsNullOrEmpty(method)) return;
if (!string.IsNullOrEmpty(field))
{
var item = new ConditionItem
{
Field = field,
Value = val.Trim(),
Prefix = prefix,
OrGroup = orGroup,
Method = (QueryMethod) Enum.Parse(typeof (QueryMethod), method)
};
model.Items.Add(item);
}
}
public void NothingShouldGoBang()
{
var factStore = new MemoryFactStore();
var aggregateRebuilder = new AggregateRebuilder(factStore);
var snapshot = new QueryModel<Student>(aggregateRebuilder);
var eventBroker = Substitute.For<IDomainEventBroker>();
Guid studentId;
using (var unitOfWork = new UnitOfWork(factStore, eventBroker, new SystemClock()))
{
var repository = new Repository<Student>(snapshot, unitOfWork);
var student = Student.Create("Fred", "Flintstone");
studentId = student.Id;
repository.Add(student);
unitOfWork.Complete();
}
using (var unitOfWork = new UnitOfWork(factStore, eventBroker, new SystemClock()))
{
var repository = new Repository<Student>(snapshot, unitOfWork);
var student = repository.GetById(studentId);
student.FirstName.ShouldBe("Fred");
student.LastName.ShouldBe("Flintstone");
}
}
/// <summary>
/// Accepts the specified visitor by calling its <see cref="IQueryModelVisitor.VisitSelectClause"/> method.
/// </summary>
/// <param name="visitor">The visitor to accept.</param>
/// <param name="queryModel">The query model in whose context this clause is visited.</param>
public void Accept (IQueryModelVisitor visitor, QueryModel queryModel)
{
ArgumentUtility.CheckNotNull ("visitor", visitor);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
visitor.VisitSelectClause (this, queryModel);
}
public static void ReWrite(QueryModel model)
{
// firstly, get the group join clauses
var groupJoin = model.BodyClauses.Where(bc => bc is GroupJoinClause).Cast<GroupJoinClause>();
if (groupJoin.Count() == 0)
{
// No group join here..
return;
}
// Now walk the tree to decide which groupings are fully aggregated (and can hence be done in hql)
var aggregateDetectorResults = IsAggregatingGroupJoin(model, groupJoin);
if (aggregateDetectorResults.AggregatingClauses.Count > 0)
{
// Re-write the select expression
model.SelectClause.TransformExpressions(s => GroupJoinSelectClauseRewriter.ReWrite(s, aggregateDetectorResults));
// Remove the aggregating group joins
foreach (GroupJoinClause aggregatingGroupJoin in aggregateDetectorResults.AggregatingClauses)
{
model.BodyClauses.Remove(aggregatingGroupJoin);
}
}
}
public void VisitQueryModel ()
{
var mainFromClauseMock = _mockRepository.StrictMock<MainFromClause> ("x", typeof (Cook), ExpressionHelper.CreateExpression());
var selectClauseMock = _mockRepository.StrictMock<SelectClause> (ExpressionHelper.CreateExpression());
var queryModel = new QueryModel (mainFromClauseMock, selectClauseMock);
using (_mockRepository.Ordered())
{
_visitorMock
.Expect (mock => mock.VisitQueryModel (queryModel))
.CallOriginalMethod (OriginalCallOptions.CreateExpectation);
mainFromClauseMock.Expect (mock => mock.Accept (_visitorMock, queryModel));
_visitorMock
.Expect (mock => PrivateInvoke.InvokeNonPublicMethod (mock, "VisitBodyClauses", queryModel.BodyClauses, queryModel));
selectClauseMock.Expect (mock => mock.Accept (_visitorMock, queryModel));
_visitorMock
.Expect (mock => PrivateInvoke.InvokeNonPublicMethod (mock, "VisitResultOperators", queryModel.ResultOperators, queryModel));
}
_mockRepository.ReplayAll();
queryModel.Accept (_visitorMock);
_mockRepository.VerifyAll();
}
private void FlattenSubQuery(SubQueryExpression subQueryExpression, FromClauseBase fromClause,
QueryModel queryModel)
{
// Move the result operator up
if (queryModel.ResultOperators.Count != 0)
{
throw new NotImplementedException();
}
var groupBy = (GroupResultOperator) subQueryExpression.QueryModel.ResultOperators[0];
// Replace the outer select clause...
queryModel.SelectClause.TransformExpressions(s => GroupBySelectClauseRewriter.ReWrite(s, groupBy, subQueryExpression.QueryModel));
queryModel.SelectClause.TransformExpressions(
s =>
new SwapQuerySourceVisitor(queryModel.MainFromClause, subQueryExpression.QueryModel.MainFromClause).Swap
(s));
MainFromClause innerMainFromClause = subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(innerMainFromClause, fromClause);
foreach (var bodyClause in subQueryExpression.QueryModel.BodyClauses)
{
queryModel.BodyClauses.Add(bodyClause);
}
queryModel.ResultOperators.Add(groupBy);
}
public void NamedEntity ()
{
// from c in Cooks select c [with name = "inner"]
var subMainFromClause = new MainFromClause ("c", typeof(Cook), Expression.Constant (Cooks));
var subSelectClause = new SelectClause (new NamedExpression ("inner", new QuerySourceReferenceExpression (subMainFromClause)));
var subQuery = new QueryModel (subMainFromClause, subSelectClause);
// from x in (subQuery) where x.ID == null select x
var outerMainFromClause = new MainFromClause ("x", typeof(Cook), new SubQueryExpression (subQuery));
var outerWhereClause = new WhereClause(Expression.Equal(Expression.MakeMemberAccess (new QuerySourceReferenceExpression (outerMainFromClause), typeof (Cook).GetProperty ("ID")), Expression.Constant (1)));
var outerSelectClause = new SelectClause (new QuerySourceReferenceExpression (outerMainFromClause));
var outerQuery = new QueryModel (outerMainFromClause, outerSelectClause);
outerQuery.BodyClauses.Add (outerWhereClause);
CheckQuery (
outerQuery,
"SELECT [q0].[inner_ID] AS [ID],[q0].[inner_FirstName] AS [FirstName],[q0].[inner_Name] AS [Name],"
+ "[q0].[inner_IsStarredCook] AS [IsStarredCook],[q0].[inner_IsFullTimeCook] AS [IsFullTimeCook],"
+ "[q0].[inner_SubstitutedID] AS [SubstitutedID],[q0].[inner_KitchenID] AS [KitchenID],"
+ "[q0].[inner_KnifeID] AS [KnifeID],[q0].[inner_KnifeClassID] AS [KnifeClassID] "
+ "FROM (SELECT [t1].[ID] AS [inner_ID],"
+ "[t1].[FirstName] AS [inner_FirstName],[t1].[Name] AS [inner_Name],[t1].[IsStarredCook] AS [inner_IsStarredCook],"
+ "[t1].[IsFullTimeCook] AS [inner_IsFullTimeCook],[t1].[SubstitutedID] AS [inner_SubstitutedID],"
+ "[t1].[KitchenID] AS [inner_KitchenID],[t1].[KnifeID] AS [inner_KnifeID],[t1].[KnifeClassID] AS [inner_KnifeClassID] "
+ "FROM [CookTable] AS [t1]) AS [q0] WHERE ([q0].[inner_ID] = @1)",
new CommandParameter("@1", 1));
}
public void SetUp ()
{
_detailSource = ExpressionHelper.CreateQueryable<Kitchen>();
_sectorSource = ExpressionHelper.CreateQueryable<Restaurant>();
var query = from s1 in ExpressionHelper.CreateQueryable<Cook>()
from sd in
(from sector in _sectorSource
where sector.ID > 10
select sector.SubKitchen)
from s2 in s1.Assistants
where sd.Name == "Maths"
select new NonTransformedTuple<Cook, Kitchen> (s1, sd);
_queryModel = ExpressionHelper.ParseQuery (query);
_mainFromClause = _queryModel.MainFromClause;
_additionalFromClause1 = (AdditionalFromClause) _queryModel.BodyClauses[0];
_additionalFromClause2 = (AdditionalFromClause) _queryModel.BodyClauses[1];
_whereClause = (WhereClause) _queryModel.BodyClauses[2];
_selectClause = _queryModel.SelectClause;
var subQueryExpressionA = (SubQueryExpression) _additionalFromClause1.FromExpression;
_innerMainFromClauseA = subQueryExpressionA.QueryModel.MainFromClause;
_innerWhereClauseA = (WhereClause) subQueryExpressionA.QueryModel.BodyClauses[0];
_visitor = new SubQueryFromClauseFlattener();
}
/// <summary>
/// Accepts the specified visitor by calling its <see cref="IQueryModelVisitor.VisitAdditionalFromClause"/> method.
/// </summary>
/// <param name="visitor">The visitor to accept.</param>
/// <param name="queryModel">The query model in whose context this clause is visited.</param>
/// <param name="index">The index of this clause in the <paramref name="queryModel"/>'s <see cref="QueryModel.BodyClauses"/> collection.</param>
public virtual void Accept (IQueryModelVisitor visitor, QueryModel queryModel, int index)
{
ArgumentUtility.CheckNotNull ("visitor", visitor);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
visitor.VisitAdditionalFromClause (this, queryModel, index);
}
/// <summary>
/// Accepts the specified visitor by calling its <see cref="IQueryModelVisitor.VisitMainFromClause"/> method.
/// </summary>
/// <param name="visitor">The visitor to accept.</param>
/// <param name="queryModel">The query model in whose context this clause is visited.</param>
public virtual void Accept (IQueryModelVisitor visitor, QueryModel queryModel)
{
ArgumentUtility.CheckNotNull ("visitor", visitor);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
visitor.VisitMainFromClause (this, queryModel);
}
/// <summary>
/// Accepts the specified visitor by calling its <see cref="IQueryModelVisitor.VisitWhereClause"/> method.
/// </summary>
/// <param name="visitor">The visitor to accept.</param>
/// <param name="queryModel">The query model in whose context this clause is visited.</param>
/// <param name="index">The index of this clause in the <paramref name="queryModel"/>'s <see cref="QueryModel.BodyClauses"/> collection.</param>
public void Accept (IQueryModelVisitor visitor, QueryModel queryModel, int index)
{
ArgumentUtility.CheckNotNull ("visitor", visitor);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
visitor.VisitWhereClause (this, queryModel, index);
}
public ActionResult Update([DataSourceRequest] DataSourceRequest request, QueryModel model)
{
try
{
PopulatePriority();
PopulateSuppliers();
PopulateStatus();
PopulateUsers();
PopulateCategory();
if (model!= null && !(model.StatusId > 0))
ModelState.AddModelError("StatusId","Status field required.");
if (model != null && ModelState.IsValid)
{
var user = userService.GetUserProfile(User.Identity.Name);
if (user == null)
throw new InvalidCredentialException("User has no permission for this operation");
model.Query = HttpUtility.HtmlDecode(model.Query);
model.RaisedById = user.UserId;
model.Supplier = new SupplierModel() { Id = user.SupplierId };
service.UpdateQuery(QueryConverter.ConvertBack(model));
var data = service.GetSupplierQueries(user.SupplierId).Select(QueryConverter.Convert);
return Json(data.ToDataSourceResult(request));
}
return Json(ModelState.ToDataSourceResult());
}
catch (Exception ex)
{
throw new InvalidOperationException(ex.ToString());
}
}
protected override void ApplyNodeSpecificSemantics (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext)
{
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
var clause = new WhereClause (GetResolvedPredicate (clauseGenerationContext));
queryModel.BodyClauses.Add (clause);
}
/// <summary>
/// Accepts the specified visitor by calling its <see cref="IQueryModelVisitor.VisitOrdering"/> method.
/// </summary>
/// <param name="visitor">The visitor to accept.</param>
/// <param name="queryModel">The query model in whose context this clause is visited.</param>
/// <param name="orderByClause">The <see cref="OrderByClause"/> in whose context this item is visited.</param>
/// <param name="index">The index of this item in the <paramref name="orderByClause"/>'s <see cref="OrderByClause.Orderings"/> collection.</param>
public virtual void Accept (IQueryModelVisitor visitor, QueryModel queryModel, OrderByClause orderByClause, int index)
{
ArgumentUtility.CheckNotNull ("visitor", visitor);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
ArgumentUtility.CheckNotNull ("orderByClause", orderByClause);
visitor.VisitOrdering (this, queryModel, orderByClause, index);
}
public static ResultOperatorRewriterResult Rewrite(QueryModel queryModel)
{
ResultOperatorRewriter rewriter = new ResultOperatorRewriter();
rewriter.VisitQueryModel(queryModel);
return new ResultOperatorRewriterResult(rewriter.resultOperators, rewriter.evaluationType);
}
protected override void ApplyNodeSpecificSemantics (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext)
{
//NOTE: Do not seal ApplyNodeSpecificSemantics() in ResultOperatorExpressionNodeBase. It is overridden by e.g. Fetch-operators.
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
var resultOperator = CreateResultOperator (clauseGenerationContext);
queryModel.ResultOperators.Add (resultOperator);
}
protected sealed override QueryModel WrapQueryModelAfterEndOfQuery (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext)
{
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
// Result operators can safely be appended to the previous query model even after another result operator, so do not wrap the previous
// query model.
return queryModel;
}
public static IQuerySource FindQuerySource(QueryModel queryModel, System.Type type)
{
var finder = new QuerySourceLocator(type);
finder.VisitQueryModel(queryModel);
return finder._querySource;
}
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext)
{
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
var resultOperator = CreateResultOperator (clauseGenerationContext);
queryModel.ResultOperators.Add (resultOperator);
return queryModel;
}
private GroupJoinClause LocateGroupJoinQuerySource(QueryModel model)
{
if (model.BodyClauses.Count > 0)
{
return null;
}
return new LocateGroupJoinQuerySource(_results).Detect(model.MainFromClause.FromExpression);
}
public static FetchQueryModelBuilder[] RemoveFetchRequestsFromQueryModel (QueryModel queryModel)
{
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
var visitor = new FetchFilteringQueryModelVisitor ();
queryModel.Accept (visitor);
return visitor.FetchQueryModelBuilders.ToArray();
}
protected override void ApplyNodeSpecificSemantics (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext)
{
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
var clause = new OrderByClause();
clause.Orderings.Add (new Ordering (GetResolvedKeySelector (clauseGenerationContext), OrderingDirection.Desc));
queryModel.BodyClauses.Add (clause);
}
public QueryModel Apply (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext)
{
if (queryModel != null)
throw new ArgumentException ("QueryModel has to be null because MainSourceExpressionNode marks the start of a query.", "queryModel");
var mainFromClause = CreateMainFromClause (clauseGenerationContext);
var defaultSelectClause = new SelectClause (new QuerySourceReferenceExpression (mainFromClause));
return new QueryModel (mainFromClause, defaultSelectClause) { ResultTypeOverride = QuerySourceType };
}
/// <summary>
/// Initializes a new instance of the <see cref="FetchQueryModelBuilder"/> class.
/// </summary>
/// <param name="fetchRequest">The fetch request.</param>
/// <param name="queryModel">The query model for which the <paramref name="fetchRequest"/> was originally defined.</param>
/// <param name="resultOperatorPosition">The result operator position where the <paramref name="fetchRequest"/> was originally located.
/// The <see cref="FetchQueryModelBuilder"/> will include all result operators prior to this position into the fetch <see cref="SourceItemQueryModel"/>,
/// but it will not include any result operators occurring after (or at) that position.</param>
public FetchQueryModelBuilder (FetchRequestBase fetchRequest, QueryModel queryModel, int resultOperatorPosition)
{
ArgumentUtility.CheckNotNull ("fetchRequest", fetchRequest);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
FetchRequest = fetchRequest;
SourceItemQueryModel = queryModel;
ResultOperatorPosition = resultOperatorPosition;
}
public QueryModel Apply (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext)
{
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
queryModel = WrapQueryModelAfterEndOfQuery (queryModel, clauseGenerationContext);
ApplyNodeSpecificSemantics (queryModel, clauseGenerationContext);
SetResultTypeOverride (queryModel);
return queryModel;
}
private static void FlattenSubQuery(SubQueryExpression subQueryExpression, FromClauseBase fromClause, QueryModel queryModel, int destinationIndex)
{
if (!CheckFlattenable(subQueryExpression.QueryModel))
{
return;
}
var mainFromClause = subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(mainFromClause, fromClause);
var innerSelectorMapping = new QuerySourceMapping();
innerSelectorMapping.AddMapping(fromClause, subQueryExpression.QueryModel.SelectClause.Selector);
queryModel.TransformExpressions(ex => ReferenceReplacingExpressionVisitor.ReplaceClauseReferences(ex, innerSelectorMapping, false));
InsertBodyClauses(subQueryExpression.QueryModel.BodyClauses, queryModel, destinationIndex);
InsertResultOperators(subQueryExpression.QueryModel.ResultOperators, queryModel);
var innerBodyClauseMapping = new QuerySourceMapping();
innerBodyClauseMapping.AddMapping(mainFromClause, new QuerySourceReferenceExpression(fromClause));
queryModel.TransformExpressions(ex => ReferenceReplacingExpressionVisitor.ReplaceClauseReferences(ex, innerBodyClauseMapping, false));
}
public override Func <QueryContext, IAsyncEnumerable <TResult> > CompileAsyncQuery <TResult>(QueryModel queryModel)
{
Check.NotNull(queryModel, nameof(queryModel));
var syncQueryExecutor = CompileQuery <TResult>(queryModel);
return(qc => syncQueryExecutor(qc).ToAsyncEnumerable());
}
public void VisitExpression_SubQuery()
{
QueryModel queryModel = ExpressionHelper.CreateQueryModel <Cook>();
CheckDelegation("VisitSubQueryExpression", new SubQueryExpression(queryModel));
}
public static void ReWrite(QueryModel model)
{
var rewriter = new MergeAggregatingResultsRewriter();
rewriter.VisitQueryModel(model);
}
public override void VisitWhereClause(WhereClause whereClause, QueryModel queryModel, int index)
{
whereClause.TransformExpressions(e => MergeAggregatingResultsInExpressionRewriter.Rewrite(e, new NameGenerator(queryModel)));
}
public List <SampleDataModel> Get(QueryModel queryModel)
{
return(this.Get <SampleDataModel>(queryModel));
}
public static void ReWrite(QueryModel model)
{
var visitor = new QueryReferenceExpressionFlattener(model);
model.TransformExpressions(visitor.Visit);
}
private IEnumerable <IncludeSpecification> CreateIncludeSpecifications(
QueryModel queryModel,
IEnumerable <IncludeResultOperator> includeResultOperators)
{
var querySourceTracingExpressionVisitor
= _querySourceTracingExpressionVisitorFactory.Create();
return(includeResultOperators
.Select(includeResultOperator =>
{
var entityType
= _queryCompilationContext.Model
.FindEntityType(includeResultOperator.PathFromQuerySource.Type);
var parts = includeResultOperator.NavigationPropertyPaths.ToArray();
var navigationPath = new INavigation[parts.Length];
for (var i = 0; i < parts.Length; i++)
{
navigationPath[i] = entityType.FindNavigation(parts[i]);
if (navigationPath[i] == null)
{
throw new InvalidOperationException(
CoreStrings.IncludeBadNavigation(parts[i], entityType.DisplayName()));
}
entityType = navigationPath[i].GetTargetType();
}
var querySourceReferenceExpression
= querySourceTracingExpressionVisitor
.FindResultQuerySourceReferenceExpression(
queryModel.SelectClause.Selector,
includeResultOperator.QuerySource);
if (querySourceReferenceExpression == null)
{
_queryCompilationContext.Logger
.LogWarning(
CoreEventId.IncludeIgnoredWarning,
() => CoreStrings.LogIgnoredInclude(
$"{includeResultOperator.QuerySource.ItemName}.{navigationPath.Select(n => n.Name).Join(".")}"));
}
return new IncludeSpecification(
includeResultOperator,
querySourceReferenceExpression,
navigationPath);
})
.Where(a =>
{
if (a.QuerySourceReferenceExpression == null)
{
return false;
}
var sequenceType = a.QuerySourceReferenceExpression.Type.TryGetSequenceType();
if (sequenceType != null &&
_queryCompilationContext.Model.FindEntityType(sequenceType) != null)
{
return false;
}
return !a.NavigationPath.Any(n => n.IsCollection());
})
.ToArray());
}
/// <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 virtual void CompileIncludes(
[NotNull] QueryModel queryModel,
[NotNull] ICollection <IncludeResultOperator> includeResultOperators,
bool trackingQuery)
{
var includeGroupings
= CreateIncludeSpecifications(queryModel, includeResultOperators)
.GroupBy(a => a.QuerySourceReferenceExpression);
foreach (var includeGrouping in includeGroupings)
{
var entityParameter = Expression.Parameter(includeGrouping.Key.Type, name: "entity");
var propertyExpressions = new List <Expression>();
var blockExpressions = new List <Expression>();
if (trackingQuery)
{
blockExpressions.Add(
Expression.Call(
_queryBufferParameter,
_startTrackingMethodInfo,
entityParameter,
Expression.Constant(
_queryCompilationContext.Model
.FindEntityType(entityParameter.Type))));
}
var includedIndex = 0;
foreach (var includeSpecification in includeGrouping)
{
_queryCompilationContext.Logger
.LogDebug(
CoreEventId.IncludingNavigation,
() => CoreStrings.LogIncludingNavigation(includeSpecification.IncludeResultOperator));
propertyExpressions.AddRange(
includeSpecification.NavigationPath
.Select((t, i) =>
includeSpecification.NavigationPath
.Take(i + 1)
.Aggregate(
(Expression)includeSpecification.QuerySourceReferenceExpression,
EntityQueryModelVisitor.CreatePropertyExpression)));
blockExpressions.Add(
BuildIncludeExpressions(
includeSpecification.NavigationPath,
entityParameter,
trackingQuery,
ref includedIndex,
navigationIndex: 0));
// TODO: Hack until new Include fully implemented
includeResultOperators.Remove(includeSpecification.IncludeResultOperator);
}
var includeReplacingExpressionVisitor
= new IncludeReplacingExpressionVisitor(
includeGrouping.Key,
Expression.Call(
IncludeMethodInfo.MakeGenericMethod(includeGrouping.Key.Type),
includeGrouping.Key,
Expression.NewArrayInit(
typeof(object),
propertyExpressions),
trackingQuery
? (Expression)
Expression.Property(
Expression.Property(
EntityQueryModelVisitor.QueryContextParameter,
propertyName: "StateManager"),
propertyName: "Value")
: Expression.Default(typeof(IStateManager)),
trackingQuery
? (Expression)
Expression.Property(
EntityQueryModelVisitor.QueryContextParameter,
propertyName: "QueryBuffer")
: Expression.Default(typeof(IQueryBuffer)),
Expression.Lambda(
Expression.Block(typeof(void), blockExpressions),
entityParameter,
_includedParameter,
_stateManagerParameter,
_queryBufferParameter)));
queryModel.SelectClause.TransformExpressions(includeReplacingExpressionVisitor.Visit);
}
}
/// <summary>
/// Executes the sql query and returns the data results
/// </summary>
/// <typeparam name="T">Data type in the main from clause (queryModel.MainFromClause.ItemType)</typeparam>
/// <param name="queryModel">Linq query model</param>
protected IEnumerable <object> GetDataResults(SqlParts sql, QueryModel queryModel)
{
IEnumerable <object> results;
OleDbDataReader data = null;
var conn = ExcelUtilities.GetConnection(_args);
var command = conn.CreateCommand();
try
{
if (conn.State == ConnectionState.Closed)
{
conn.Open();
}
command.CommandText = sql.ToString();
command.Parameters.AddRange(sql.Parameters.ToArray());
try { data = command.ExecuteReader(); }
catch (OleDbException e)
{
if (e.Message.Contains(_args.WorksheetName))
{
throw new DataException(
string.Format("'{0}' is not a valid worksheet name in file {3}. Valid worksheet names are: '{1}'. Error received: {2}",
_args.WorksheetName, string.Join("', '", ExcelUtilities.GetWorksheetNames(_args.FileName).ToArray()), e.Message, _args.FileName), e);
}
if (!CheckIfInvalidColumnNameUsed(sql))
{
throw e;
}
}
var columns = ExcelUtilities.GetColumnNames(data);
LogColumnMappingWarnings(columns);
if (columns.Count() == 1 && columns.First() == "Expr1000")
{
results = GetScalarResults(data);
}
else if (queryModel.MainFromClause.ItemType == typeof(Row))
{
results = GetRowResults(data, columns);
}
else if (queryModel.MainFromClause.ItemType == typeof(RowNoHeader))
{
results = GetRowNoHeaderResults(data);
}
else
{
results = GetTypeResults(data, columns, queryModel);
}
}
finally
{
command.Dispose();
if (!_args.UsePersistentConnection)
{
conn.Dispose();
_args.PersistentConnection = null;
}
}
return(results);
}
private IEnumerable <object> GetTypeResults(IDataReader data, IEnumerable <string> columns, QueryModel queryModel)
{
var results = new List <object>();
var fromType = queryModel.MainFromClause.ItemType;
var props = fromType.GetProperties();
if (_args.StrictMapping.Value != StrictMappingType.None)
{
this.ConfirmStrictMapping(columns, props, _args.StrictMapping.Value);
}
while (data.Read())
{
var result = Activator.CreateInstance(fromType);
foreach (var prop in props)
{
var columnName = (_args.ColumnMappings.ContainsKey(prop.Name)) ?
_args.ColumnMappings[prop.Name] :
prop.Name;
if (columns.Contains(columnName))
{
var value = GetColumnValue(data, columnName, prop.Name).Cast(prop.PropertyType);
value = TrimStringValue(value);
result.SetProperty(prop.Name, value);
}
}
results.Add(result);
}
return(results.AsEnumerable());
}
private void AdjustForResultOperators(QueryModel queryModel)
{
var referencedQuerySource
= queryModel.SelectClause.Selector.TryGetReferencedQuerySource()
?? queryModel.MainFromClause.FromExpression.TryGetReferencedQuerySource();
// If there is any CastResultOperator then we need to do client eval unless it is doing same cast.
if (queryModel.ResultOperators.OfType <CastResultOperator>().Any() &&
referencedQuerySource != null)
{
PromoteQuerySource(referencedQuerySource);
return;
}
var isSubQuery = _queryModelStack.Count > 0;
var finalResultOperator = queryModel.ResultOperators.LastOrDefault();
if (isSubQuery &&
finalResultOperator is GroupResultOperator groupResultOperator &&
queryModel.ResultOperators.OfType <GroupResultOperator>().Count() == 1)
{
if (!(groupResultOperator.KeySelector is MemberInitExpression))
{
// This is to compensate for the fact that we have to demote querysources found in selector for GroupBy
// TODO: See #11215
foreach (var querySource in TraverseQuerySources(queryModel.SelectClause.Selector))
{
DemoteQuerySource(querySource);
}
if (groupResultOperator.ElementSelector is QuerySourceReferenceExpression qsre)
{
DemoteQuerySource(qsre.ReferencedQuerySource);
}
return;
}
}
// The selector may not have been a QSRE but this query model may still have something that needs adjusted.
// Example:
// context.Orders.GroupBy(o => o.CustomerId).Select(g => new { g.Key, g.Sum(o => o.TotalAmount) })
// The g.Sum(...) will result in a subquery model like { from Order o in [g] select o.TotalAmount => Sum() }.
// In that case we need to ensure that the referenced query source [g] is demoted.
if (referencedQuerySource == null)
{
return;
}
// If the GroupResultOperator is not last (as captured by above)
// then we promote first GroupResultOperator to fall through streaming group by
var firstGroupResultOperator = queryModel.ResultOperators.OfType <GroupResultOperator>().FirstOrDefault();
if (firstGroupResultOperator != null)
{
PromoteQuerySource(firstGroupResultOperator);
}
var unreachableFromParentSelector =
isSubQuery && _querySourceTracingExpressionVisitor
.FindResultQuerySourceReferenceExpression(
_queryModelStack.Peek().SelectClause.Selector,
referencedQuerySource) == null;
if (finalResultOperator is SingleResultOperator ||
finalResultOperator is FirstResultOperator ||
finalResultOperator is LastResultOperator)
{
// If not a subquery or if reachable from the parent selector
// we would not want to fall through to one of the next blocks.
if (unreachableFromParentSelector)
{
DemoteQuerySourceAndUnderlyingFromClause(referencedQuerySource);
}
return;
}
if (ConvergesToSingleValue(queryModel)
// This is to preserve QuerySource from MainFromClause when selector is ConstantExpression
// Since we would cause client evaluation from ConstantExpression.
// TODO: See #11215
&& !(queryModel.SelectClause.Selector is ConstantExpression))
{
// This is a top-level query that was not Single/First/Last
// but returns a single/scalar value (Avg/Min/Max/etc.)
// or a subquery that belongs to some outer-level query that returns
// a single or scalar value. The referenced query source should be
// re-promoted later if necessary.
// For top-level Contains we cannot translate it since Item is not Expression
if (!isSubQuery &&
finalResultOperator is ContainsResultOperator containsResultOperator)
{
return;
}
// If we are selecting from Grouping source but it is not GroupByAggregate Query
// then do not demote Grouping source since we still need to create groups.
if (queryModel.MainFromClause.FromExpression.Type.IsGrouping() &&
!IsGroupByAggregateSubQuery(queryModel))
{
return;
}
DemoteQuerySourceAndUnderlyingFromClause(referencedQuerySource);
return;
}
if (isSubQuery && (unreachableFromParentSelector || finalResultOperator is DefaultIfEmptyResultOperator))
{
DemoteQuerySourceAndUnderlyingFromClause(referencedQuerySource);
}
}
/// <summary>
/// Executes a query with a scalar result, i.e. a query that ends with a result operator such as Count, Sum, or Average.
/// </summary>
public T ExecuteScalar <T>(QueryModel queryModel)
{
return(ExecuteSingle <T>(queryModel, false));
}
public virtual Func <QueryContext, IAsyncEnumerable <TResult> > CreateAsyncQueryExecutor <TResult>([NotNull] QueryModel queryModel)
{
Check.NotNull(queryModel, nameof(queryModel));
using (QueryCompilationContext.Logger.BeginScopeImpl(this))
{
QueryCompilationContext.Logger
.LogVerbose(
CoreLoggingEventId.CompilingQueryModel,
() => CoreStrings.LogCompilingQueryModel(queryModel));
_blockTaskExpressions = false;
ExtractQueryAnnotations(queryModel);
OptimizeQueryModel(queryModel);
QueryCompilationContext.FindQuerySourcesRequiringMaterialization(this, queryModel);
QueryCompilationContext.DetermineQueryBufferRequirement(queryModel);
VisitQueryModel(queryModel);
AsyncSingleResultToSequence(queryModel);
IncludeNavigations(queryModel);
TrackEntitiesInResults <TResult>(queryModel);
InterceptExceptions();
return(CreateExecutorLambda <IAsyncEnumerable <TResult> >());
}
}
/// <summary> /// Modifies the given query model for fetching, adding new <see cref="AdditionalFromClause"/> instances and changing the /// <see cref="SelectClause"/> as needed. /// This method is called by <see cref="CreateFetchQueryModel"/> in the process of creating the new fetch query model. /// </summary> /// <param name="fetchQueryModel">The fetch query model to modify.</param> protected abstract void ModifyFetchQueryModel(QueryModel fetchQueryModel);
public async Task <PageData <T> > GetPageList(QueryModel queryModel)
{
return(await DapperExtensions.PageQuery <T>(_unitOfWork, queryModel));
}
private QueryReferenceExpressionFlattener(QueryModel model)
{
_model = model;
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
//Affects SQL result operators
if (resultOperator is TakeResultOperator)
{
var take = resultOperator as TakeResultOperator;
SqlStatement.Aggregate = string.Format("TOP {0} *", take.Count);
}
else if (resultOperator is AverageResultOperator)
{
UpdateAggregate(queryModel, "AVG");
}
else if (resultOperator is CountResultOperator)
{
SqlStatement.Aggregate = "COUNT(*)";
}
else if (resultOperator is LongCountResultOperator)
{
SqlStatement.Aggregate = "COUNT(*)";
}
else if (resultOperator is FirstResultOperator)
{
SqlStatement.Aggregate = "TOP 1 *";
}
else if (resultOperator is MaxResultOperator)
{
UpdateAggregate(queryModel, "MAX");
}
else if (resultOperator is MinResultOperator)
{
UpdateAggregate(queryModel, "MIN");
}
else if (resultOperator is SumResultOperator)
{
UpdateAggregate(queryModel, "SUM");
}
else if (resultOperator is DistinctResultOperator)
{
ProcessDistinctAggregate(queryModel);
}
//Not supported result operators
else if (resultOperator is ContainsResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Contains() method");
}
else if (resultOperator is DefaultIfEmptyResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the DefaultIfEmpty() method");
}
else if (resultOperator is ExceptResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Except() method");
}
else if (resultOperator is GroupResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Group() method");
}
else if (resultOperator is IntersectResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Intersect() method");
}
else if (resultOperator is OfTypeResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the OfType() method");
}
else if (resultOperator is SingleResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Single() method. Use the First() method instead");
}
else if (resultOperator is UnionResultOperator)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Union() method");
}
base.VisitResultOperator(resultOperator, queryModel, index);
}
public new Func <QueryContext, IAsyncEnumerable <TResult> > CreateQueryExecutor <TResult>([NotNull] QueryModel queryModel)
{
Check.NotNull(queryModel, "queryModel");
VisitQueryModel(queryModel);
if (_streamedSequenceInfo == null)
{
_expression
= Expression.Call(
_taskToSequenceShim.MakeGenericMethod(typeof(TResult)),
_expression);
}
return(Expression
.Lambda <Func <QueryContext, IAsyncEnumerable <TResult> > >(_expression, _queryContextParameter)
.Compile());
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Join() method");
}
public override void VisitSelectClause(SelectClause selectClause, QueryModel queryModel)
{
selectClause.TransformExpressions(e => MergeAggregatingResultsInExpressionRewriter.Rewrite(e, new NameGenerator(queryModel)));
}
public override void VisitGroupJoinClause(GroupJoinClause groupJoinClause, QueryModel queryModel, int index)
{
throw new NotSupportedException("LinqToExcel does not provide support for group join");
}
public async Task <IViewComponentResult> InvokeAsync(string field, QueryModel queryModel)
{
// daydate = DateTime.Now;
ViewData["field"] = field;
return(await Task.FromResult((IViewComponentResult)View("Default", queryModel)));
}
protected override void VisitBodyClauses(ObservableCollection <IBodyClause> bodyClauses, QueryModel queryModel)
{
var orderClause = bodyClauses
.FirstOrDefault(x => x.GetType() == typeof(OrderByClause))
as OrderByClause;
if (orderClause != null)
{
var columnName = "";
var exp = orderClause.Orderings.First().Expression;
if (exp is MemberExpression)
{
var mExp = exp as MemberExpression;
columnName = (_args.ColumnMappings.ContainsKey(mExp.Member.Name)) ?
_args.ColumnMappings[mExp.Member.Name] :
mExp.Member.Name;
}
else if (exp is MethodCallExpression)
{
//row["ColumnName"] is being used in order by statement
columnName = ((MethodCallExpression)exp).Arguments.First()
.ToString().Replace("\"", "");
}
SqlStatement.OrderBy = columnName;
SqlStatement.ColumnNamesUsed.Add(columnName);
var orderDirection = orderClause.Orderings.First().OrderingDirection;
SqlStatement.OrderByAsc = (orderDirection == OrderingDirection.Asc);
}
base.VisitBodyClauses(bodyClauses, queryModel);
}
public virtual void Rewrite([NotNull] QueryModel queryModel)
{
Check.NotNull(queryModel, nameof(queryModel));
queryModel.TransformExpressions(Visit);
}
ICloneableQueryAnnotation ICloneableQueryAnnotation.Clone(IQuerySource querySource, QueryModel queryModel)
=> new ValueFromOpenJsonOperator(ParseInfo, Json, Path)
{
QuerySource = querySource, QueryModel = queryModel
};
internal static void InsertResultOperators(IEnumerable <ResultOperatorBase> resultOperators, QueryModel queryModel)
{
var index = 0;
foreach (var bodyClause in resultOperators)
{
queryModel.ResultOperators.Insert(index, bodyClause);
++index;
}
}
private SubQueryExpression CreateSubQueryNode(MethodCallExpression methodCallExpression)
{
QueryModel queryModel = _queryParser.GetParsedQuery(methodCallExpression);
return(new SubQueryExpression(queryModel));
}
protected virtual void TrackEntitiesInResults <TResult>(
[NotNull] QueryModel queryModel)
{
Check.NotNull(queryModel, nameof(queryModel));
var lastTrackingModifier
= QueryCompilationContext.QueryAnnotations
.OfType <QueryAnnotation>()
.LastOrDefault(
qa => qa.IsCallTo(EntityFrameworkQueryableExtensions.AsNoTrackingMethodInfo) ||
qa.IsCallTo(EntityFrameworkQueryableExtensions.AsTrackingMethodInfo));
if (queryModel.GetOutputDataInfo() is StreamedScalarValueInfo ||
lastTrackingModifier
?.IsCallTo(EntityFrameworkQueryableExtensions.AsNoTrackingMethodInfo) == true ||
(!QueryCompilationContext.TrackQueryResults &&
lastTrackingModifier
?.IsCallTo(EntityFrameworkQueryableExtensions.AsTrackingMethodInfo) != true))
{
return;
}
var entityTrackingInfos
= _entityResultFindingExpressionVisitorFactory.Create(QueryCompilationContext)
.FindEntitiesInResult(queryModel.SelectClause.Selector);
if (entityTrackingInfos.Any())
{
var resultItemType = _expression.Type.GetSequenceType();
var resultItemTypeInfo = resultItemType.GetTypeInfo();
MethodInfo trackingMethod;
if (resultItemTypeInfo.IsGenericType &&
(resultItemTypeInfo.GetGenericTypeDefinition() == typeof(IGrouping <,>) ||
resultItemTypeInfo.GetGenericTypeDefinition() == typeof(IAsyncGrouping <,>)))
{
trackingMethod
= LinqOperatorProvider.TrackGroupedEntities
.MakeGenericMethod(
resultItemType.GenericTypeArguments[0],
resultItemType.GenericTypeArguments[1],
queryModel.SelectClause.Selector.Type);
}
else
{
trackingMethod
= LinqOperatorProvider.TrackEntities
.MakeGenericMethod(
resultItemType,
queryModel.SelectClause.Selector.Type);
}
_expression
= Expression.Call(
trackingMethod,
_expression,
QueryContextParameter,
Expression.Constant(entityTrackingInfos),
Expression.Constant(
_getEntityAccessors
.MakeGenericMethod(queryModel.SelectClause.Selector.Type)
.Invoke(
null,
new object[]
{
entityTrackingInfos,
queryModel.SelectClause.Selector
})));
}
}
protected void Compile(
QueryCompilationContext queryCompilationContext,
QueryModel queryModel,
bool trackingQuery,
bool asyncQuery,
ref int collectionIncludeId,
QuerySourceReferenceExpression targetQuerySourceReferenceExpression)
{
var entityParameter
= Expression.Parameter(targetQuerySourceReferenceExpression.Type, name: "entity");
var propertyExpressions = new List <Expression>();
var blockExpressions = new List <Expression>();
var entityType
= queryCompilationContext.FindEntityType(targetQuerySourceReferenceExpression.ReferencedQuerySource)
?? queryCompilationContext.Model.FindEntityType(entityParameter.Type);
if (entityType.IsQueryType)
{
trackingQuery = false;
}
if (trackingQuery)
{
blockExpressions.Add(
Expression.Call(
Expression.Property(
EntityQueryModelVisitor.QueryContextParameter,
nameof(QueryContext.QueryBuffer)),
_queryBufferStartTrackingMethodInfo,
entityParameter,
Expression.Constant(entityType)));
}
var includedIndex = 0;
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (var includeLoadTreeNode in Children)
{
blockExpressions.Add(
includeLoadTreeNode.Compile(
queryCompilationContext,
targetQuerySourceReferenceExpression,
entityParameter,
propertyExpressions,
trackingQuery,
asyncQuery,
ref includedIndex,
ref collectionIncludeId));
}
if (blockExpressions.Count > 1 ||
blockExpressions.Count == 1 &&
!trackingQuery)
{
AwaitTaskExpressions(asyncQuery, blockExpressions);
var includeExpression
= blockExpressions.Last().Type == typeof(Task)
? new TaskBlockingExpressionVisitor()
.Visit(
Expression.Call(
_includeAsyncMethodInfo
.MakeGenericMethod(targetQuerySourceReferenceExpression.Type),
EntityQueryModelVisitor.QueryContextParameter,
targetQuerySourceReferenceExpression,
Expression.NewArrayInit(typeof(object), propertyExpressions),
Expression.Lambda(
Expression.Block(blockExpressions),
EntityQueryModelVisitor.QueryContextParameter,
entityParameter,
_includedParameter,
CancellationTokenParameter),
CancellationTokenParameter))
: Expression.Call(
_includeMethodInfo.MakeGenericMethod(targetQuerySourceReferenceExpression.Type),
EntityQueryModelVisitor.QueryContextParameter,
targetQuerySourceReferenceExpression,
Expression.NewArrayInit(typeof(object), propertyExpressions),
Expression.Lambda(
Expression.Block(typeof(void), blockExpressions),
EntityQueryModelVisitor.QueryContextParameter,
entityParameter,
_includedParameter));
ApplyIncludeExpressionsToQueryModel(
queryModel, targetQuerySourceReferenceExpression, includeExpression);
}
}