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 override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
base.VisitMainFromClause(fromClause, queryModel);
var isUpdateQuery = queryModel.ResultOperators.LastOrDefault() is UpdateAllResultOperator;
if (!isUpdateQuery)
{
_builder.Append("from ");
}
ValidateFromClause(fromClause);
_aliases.AppendAsClause(_builder, fromClause).Append(' ');
var i = 0;
foreach (var additionalFrom in queryModel.BodyClauses.OfType <AdditionalFromClause>())
{
_builder.Append(", ");
ValidateFromClause(additionalFrom);
VisitAdditionalFromClause(additionalFrom, queryModel, i++);
}
if (isUpdateQuery)
{
BuildSetClauseForUpdateAll(queryModel);
}
}
internal static SelectExpression SelectAndFirstDatabaseExpressions(AdventureWorks adventureWorks)
{
QueryCompilationContext compilationContext = adventureWorks.GetService <IQueryCompilationContextFactory>()
.Create(async: false);
SelectExpression selectExpression = new SelectExpression(
dependencies: new SelectExpressionDependencies(adventureWorks.GetService <IQuerySqlGeneratorFactory>(), adventureWorks.GetService <IRelationalTypeMappingSource>()),
queryCompilationContext: (RelationalQueryCompilationContext)compilationContext);
MainFromClause querySource = new MainFromClause(
itemName: "product",
itemType: typeof(Product),
fromExpression: Expression.Constant(adventureWorks.ProductCategories));
TableExpression tableExpression = new TableExpression(
table: nameof(Product),
schema: AdventureWorks.Production,
alias: querySource.ItemName,
querySource: querySource);
selectExpression.AddTable(tableExpression);
IEntityType productEntityType = adventureWorks.Model.FindEntityType(typeof(Product));
IProperty nameProperty = productEntityType.FindProperty(nameof(Product.Name));
selectExpression.AddToProjection(new ColumnExpression(
name: nameof(Product.Name), property: nameProperty, tableExpression: tableExpression));
selectExpression.Limit = Expression.Constant(1);
return(selectExpression.WriteLine());
}
internal static SelectExpression WhereAndSelectDatabaseExpressions(AdventureWorks adventureWorks)
{
QueryCompilationContext compilationContext = adventureWorks.GetService <IQueryCompilationContextFactory>()
.Create(async: false);
SelectExpression databaseExpression = new SelectExpression(
dependencies: new SelectExpressionDependencies(adventureWorks.GetService <IQuerySqlGeneratorFactory>(), adventureWorks.GetService <IRelationalTypeMappingSource>()),
queryCompilationContext: (RelationalQueryCompilationContext)compilationContext);
MainFromClause querySource = new MainFromClause(
itemName: "product",
itemType: typeof(Product),
fromExpression: Expression.Constant(adventureWorks.ProductCategories));
TableExpression tableExpression = new TableExpression(
table: nameof(Product),
schema: AdventureWorks.Production,
alias: querySource.ItemName,
querySource: querySource);
databaseExpression.AddTable(tableExpression);
IEntityType productEntityType = adventureWorks.Model.FindEntityType(typeof(Product));
IProperty nameProperty = productEntityType.FindProperty(nameof(Product.Name));
ColumnExpression nameColumn = new ColumnExpression(
name: nameof(Product.Name), property: nameProperty, tableExpression: tableExpression);
databaseExpression.AddToProjection(nameColumn);
databaseExpression.AddToPredicate(Expression.GreaterThan(
left: new ExplicitCastExpression(
operand: new SqlFunctionExpression(
functionName: "LEN",
returnType: typeof(int),
arguments: new Expression[] { nameColumn }),
type: typeof(int)),
right: Expression.Constant(10)));
return(databaseExpression.WriteLine());
}
public void SetUp()
{
_fromClause = ExpressionHelper.CreateMainFromClause_Int("i", typeof(int), ExpressionHelper.CreateIntQueryable());
_predicate = ExpressionHelper.Resolve <int, bool> (_fromClause, j => j > 2);
_resultOperator = new AllResultOperator(_predicate);
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
var xConstant = (ConstantExpression)fromClause.FromExpression;
var relinqQueryable = (IRelinqQueryable)xConstant.Value;
queryBuilder.SetSource(fromClause.ItemType, relinqQueryable.SourceName);
AdditionalFromClause additionalFromClause = null;
foreach (var c in queryModel.BodyClauses)
{
additionalFromClause = c as AdditionalFromClause;
if (additionalFromClause != null)
{
break;
}
}
if (additionalFromClause != null)
{
memberAccessBuilder.Map(fromClause, "src.Ссылка");
var xSubquery = (SubQueryExpression)additionalFromClause.FromExpression;
memberAccessBuilder.Map(xSubquery.QueryModel.MainFromClause, "src");
}
else
{
memberAccessBuilder.Map(fromClause, "src");
}
base.VisitMainFromClause(fromClause, queryModel);
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
MainFromEntityClauseVisitor mainFromEntityClauseVisitor = new MainFromEntityClauseVisitor(fromClause);
_queryMetadata.EntityName = mainFromEntityClauseVisitor.EntityLogicalName;
_queryMetadata.EntityType = mainFromEntityClauseVisitor.EntityType;
}
public MainFromEntityClauseVisitor(MainFromClause fromClause)
{
MainFromEntityExpressionTreeVisitor mainFromEntityExpressionTreeVisitor = new MainFromEntityExpressionTreeVisitor(fromClause.FromExpression);
EntityLogicalName = mainFromEntityExpressionTreeVisitor.EntityLogicalName;
EntityType = mainFromEntityExpressionTreeVisitor.EntityType;
}
public virtual void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
ArgumentUtility.CheckNotNull("fromClause", fromClause);
ArgumentUtility.CheckNotNull("queryModel", queryModel);
// nothing to do here
}
/// <summary>
/// Registers a mapping between correlated collection query models and metadata needed to process them.
/// </summary>
/// <param name="mainFromClause"> The main from clause.</param>
/// <param name="trackingQuery"> Flag indicating whether query should be tracked or not. </param>
/// <param name="firstNavigation"> First navigation in the chain leading to collection navigation that is being optimized. </param>
/// <param name="collectionNavigation"> Collection navigation that is being optimized. </param>
/// <param name="parentQuerySource"> Query source that is origin of the collection navigation. </param>
public virtual void RegisterCorrelatedSubqueryMetadata(
[NotNull] MainFromClause mainFromClause,
bool trackingQuery,
[NotNull] INavigation firstNavigation,
[NotNull] INavigation collectionNavigation,
[NotNull] IQuerySource parentQuerySource)
{
Check.NotNull(mainFromClause, nameof(mainFromClause));
Check.NotNull(firstNavigation, nameof(firstNavigation));
Check.NotNull(collectionNavigation, nameof(collectionNavigation));
Check.NotNull(parentQuerySource, nameof(parentQuerySource));
if (_correlatedSubqueryMetadataMap == null)
{
_correlatedSubqueryMetadataMap = new Dictionary <MainFromClause, CorrelatedSubqueryMetadata>();
}
_correlatedSubqueryMetadataMap[mainFromClause]
= new CorrelatedSubqueryMetadata(
_correlatedSubqueryMetadataMap.Count,
trackingQuery,
firstNavigation,
collectionNavigation,
parentQuerySource);
}
/// <summary>
/// Visits the main from clause.
/// </summary>
/// <param name="fromClause">From clause.</param>
/// <param name="queryModel">The query model.</param>
/// <remarks></remarks>
public override void VisitMainFromClause(MainFromClause fromClause, Remotion.Linq.QueryModel queryModel)
{
var sourceAsConstant = queryModel.MainFromClause.FromExpression as ConstantExpression;
if (sourceAsConstant != null)
{
_queryDescription.SetFromClause("", HierarchyScope.AllOrNone, FromClause.RevisionStatusNotSpecifiedType);
// Tues 1 Nov: _queryDescription.SetResultFilterClause(fromClause.ItemType, ResultFilterType.Sequence, -1);
_queryDescription.SetResultFilterClause(GetResultType(fromClause, queryModel), ResultFilterType.Sequence, -1);
RunCustomModifiers(queryModel);
}
var sourceAsSubQuery = fromClause.FromExpression as SubQueryExpression;
if (sourceAsSubQuery != null)
{
var subQueryModel = sourceAsSubQuery.QueryModel;
RunCustomModifiers(subQueryModel);
}
// If the Where clause is null, we have a request for "get all", but the VisitWhereClause method never runs (thanks Remotion!)
// so let's fake it here
if (!queryModel.BodyClauses.Any())
{
queryModel.BodyClauses.Add(new WhereClause(Expression.Equal(IgnoreExpression, IgnoreExpression)));
}
base.VisitMainFromClause(fromClause, queryModel);
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
string fromTableName = fromClause.ItemType.Name;
var EntityMapping = _context.Model.GetEntityMapping(fromClause.ItemType);
// TODO: This should fail if null?
if (!string.IsNullOrEmpty(EntityMapping.TableName))
{
fromTableName = EntityMapping.TableName;
}
if (fromClause.ItemName.StartsWith("<generated>_", StringComparison.Ordinal))
{
// TODO: Use a shortened unique identifier.
fromClause.ItemName = fromClause.ItemName.Replace("<generated>_", fromTableName + "_");
}
SubQueryFromClauseModelVisitor.Visit(_context, _parameters, queryModel);
_fromPart = string.Format("{0} AS {1}", fromTableName, fromClause.ItemName);
base.VisitMainFromClause(fromClause, queryModel);
}
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 override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
ArgumentUtility.CheckNotNull("fromClause", fromClause);
ArgumentUtility.CheckNotNull("queryModel", queryModel);
AddQuerySource(fromClause, fromClause.FromExpression);
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
Log("VisitMainFromClause: " + fromClause, logLevel++);
_queryParts.AddFromPart(fromClause);
base.VisitMainFromClause(fromClause, queryModel);
logLevel--;
}
/// <summary>
/// Creates a new <see cref="QueryModel"/> that has this <see cref="QueryModel"/> as a sub-query in its <see cref="MainFromClause"/>.
/// </summary>
/// <param name="itemName">The name of the new <see cref="QueryModel"/>'s <see cref="FromClauseBase.ItemName"/>.</param>
/// <returns>A new <see cref="QueryModel"/> whose <see cref="MainFromClause"/>'s <see cref="FromClauseBase.FromExpression"/> is a
/// <see cref="SubQueryExpression"/> that holds this <see cref="QueryModel"/> instance.</returns>
public QueryModel ConvertToSubQuery(string itemName)
{
ArgumentUtility.CheckNotNullOrEmpty("itemName", itemName);
var outputDataInfo = GetOutputDataInfo() as StreamedSequenceInfo;
if (outputDataInfo == null)
{
var message = string.Format(
"The query must return a sequence of items, but it selects a single object of type '{0}'.",
GetOutputDataInfo().DataType);
throw new InvalidOperationException(message);
}
// from x in (sourceItemQuery)
// select x
var mainFromClause = new MainFromClause(
itemName,
outputDataInfo.ResultItemType,
new SubQueryExpression(this));
var selectClause = new SelectClause(new QuerySourceReferenceExpression(mainFromClause));
return(new QueryModel(mainFromClause, selectClause));
}
public void ToString_IdentityQuery()
{
var mainFromClause = new MainFromClause("x", typeof(Cook), Expression.Constant(0));
var queryModel = new QueryModel(mainFromClause, new SelectClause(new QuerySourceReferenceExpression(mainFromClause)));
Assert.That(queryModel.ToString(), Is.EqualTo("0"));
}
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();
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
Log.Trace(() => string.Format("Original QueryModel: {0}", queryModel));
new AggressiveSubQueryFromClauseFlattener().VisitMainFromClause(fromClause, queryModel);
Log.Trace(() => string.Format("Transformed QueryModel after AggressiveSubQueryFromClauseFlattener: {0}", queryModel));
base.VisitMainFromClause(fromClause, queryModel);
}
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 override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
if (IsSubquery)
{
AppendLine();
}
if (queryModel.ResultOperators.Count > 0)
{
TransformingVisitor.StringBuilder.Append("(");
}
if (TransformingVisitor.GenerateUniqueQsreIds)
{
var i = TransformingVisitor.VisitedQuerySources.IndexOf(fromClause);
if (i == -1)
{
i = TransformingVisitor.VisitedQuerySources.Count;
TransformingVisitor.VisitedQuerySources.Add(fromClause);
}
TransformingVisitor.StringBuilder.Append($"from {fromClause.ItemType.ShortDisplayName()} {fromClause.ItemName}{{{i}}} in ");
}
else
{
TransformingVisitor.StringBuilder.Append($"from {fromClause.ItemType.ShortDisplayName()} {fromClause.ItemName} in ");
}
base.VisitMainFromClause(fromClause, queryModel);
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
if (fromClause.FromExpression is SubQueryExpression subqueryExpression)
{
VisitQueryModel(subqueryExpression.QueryModel);
}
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
if (fromClause != _exemptQuerySource)
{
fromClause.TransformExpressions(_innerVisitor.Visit);
}
}
/// <summary>
/// 调用 from 语句时执行
/// </summary>
/// <param name="fromClause"></param>
/// <param name="queryModel"></param>
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
// 构建 FromParts
// 类似 {NHibernate.ReLinq.Sample.UnitTests.DomainObjects.PhoneNumber} as {pn}
_queryParts.AddFromPart(fromClause);
base.VisitMainFromClause(fromClause, queryModel);
}
public void SetUp()
{
_mainFromClause = ExpressionHelper.CreateMainFromClause_Int();
_selectClause = ExpressionHelper.CreateSelectClause();
_queryModel = new QueryModel(_mainFromClause, _selectClause);
_querySourceMapping = new QuerySourceMapping();
}
/// <summary>
/// Clones this <see cref="QueryModel"/>, returning a new <see cref="QueryModel"/> equivalent to this instance, but with its clauses being
/// clones of this instance's clauses. Any <see cref="QuerySourceReferenceExpression"/> in the cloned clauses that points back to another clause
/// in this <see cref="QueryModel"/> (including its subqueries) is adjusted to point to the respective clones in the cloned
/// <see cref="QueryModel"/>. Any subquery nested in the <see cref="QueryModel"/> is also cloned.
/// </summary>
/// <param name="querySourceMapping">The <see cref="QuerySourceMapping"/> defining how to adjust instances of
/// <see cref="QuerySourceReferenceExpression"/> in the cloned <see cref="QueryModel"/>. If there is a <see cref="QuerySourceReferenceExpression"/>
/// that points out of the <see cref="QueryModel"/> being cloned, specify its replacement via this parameter. At the end of the cloning process,
/// this object maps all the clauses in this original <see cref="QueryModel"/> to the clones created in the process.
/// </param>
public QueryModel Clone(QuerySourceMapping querySourceMapping)
{
ArgumentUtility.CheckNotNull("querySourceMapping", querySourceMapping);
var cloneContext = new CloneContext(querySourceMapping);
var queryModelBuilder = new QueryModelBuilder();
queryModelBuilder.AddClause(MainFromClause.Clone(cloneContext));
foreach (var bodyClause in BodyClauses)
{
queryModelBuilder.AddClause(bodyClause.Clone(cloneContext));
}
queryModelBuilder.AddClause(SelectClause.Clone(cloneContext));
foreach (var resultOperator in ResultOperators)
{
var resultOperatorClone = resultOperator.Clone(cloneContext);
queryModelBuilder.AddResultOperator(resultOperatorClone);
}
var clone = queryModelBuilder.Build();
clone.TransformExpressions(ex => CloningExpressionTreeVisitor.AdjustExpressionAfterCloning(ex, cloneContext.QuerySourceMapping));
clone.ResultTypeOverride = ResultTypeOverride;
return(clone);
}
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);
}
/// <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 override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
if (resultOperator is ValueFromSequenceResultOperatorBase &&
!(resultOperator is ChoiceResultOperatorBase) &&
!queryModel.ResultOperators
.Any(r => r is TakeResultOperator || r is SkipResultOperator))
{
for (var i = queryModel.BodyClauses.Count - 1; i >= 0; i--)
{
if (queryModel.BodyClauses[i] is OrderByClause)
{
queryModel.BodyClauses.RemoveAt(i);
}
}
}
if (resultOperator is OfTypeResultOperator ofTypeOperator)
{
var searchedItemType = ofTypeOperator.SearchedItemType;
if (searchedItemType == queryModel.MainFromClause.ItemType)
{
queryModel.ResultOperators.RemoveAt(index);
}
else
{
var entityType = _queryCompilationContext.Model.FindEntityType(searchedItemType);
if (entityType != null)
{
var oldQuerySource = queryModel.MainFromClause;
if (((oldQuerySource.FromExpression as ConstantExpression)?.Value as IQueryable)?.Provider
is IAsyncQueryProvider entityQueryProvider)
{
queryModel.ResultOperators.RemoveAt(index);
var newMainFromClause
= new MainFromClause(
oldQuerySource.ItemName,
entityType.ClrType,
entityQueryProvider.CreateEntityQueryableExpression(entityType.ClrType));
queryModel.MainFromClause = newMainFromClause;
UpdateQuerySourceMapping(
queryModel,
oldQuerySource,
new QuerySourceReferenceExpression(newMainFromClause));
}
}
}
}
ProcessSetResultOperator(resultOperator);
TryOptimizeContains(resultOperator, queryModel);
base.VisitResultOperator(resultOperator, queryModel, index);
}
/// <summary>
/// 解析 from 语句
/// </summary>
/// <param name="fromClause"></param>
/// <param name="queryModel"></param>
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
string itemName = fromClause.ItemName.Contains("<generated>") ? "t" : fromClause.ItemName.ToLower();
this.commandBuilder.FromParts.Add(string.Format("{0}{1}{2} {3}", Constants.LeftQuote, fromClause.ItemType.Name, Constants.RightQuote, itemName));
base.VisitMainFromClause(fromClause, queryModel);
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
if (fromClause.FromExpression is SubQueryExpression subQueryExpression)
{
FlattenSubQuery(subQueryExpression, fromClause, queryModel, 0);
}
base.VisitMainFromClause(fromClause, queryModel);
}
public void SetFrom(MainFromClause from)
{
MainFrom = from;
if (from != QuerySourceConverterFactory.GetOriginalSource(from))
{
TryToSimplifyMainFrom();
}
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
if (_type == fromClause.ItemType)
{
_querySource = fromClause;
}
else
{
base.VisitMainFromClause(fromClause, queryModel);
}
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
var subQueryExpression = fromClause.FromExpression as SubQueryExpression;
if ((subQueryExpression != null) &&
(subQueryExpression.QueryModel.ResultOperators.Count() == 1) &&
(subQueryExpression.QueryModel.ResultOperators[0] is GroupResultOperator) &&
(IsNonAggregatingGroupBy(queryModel)))
{
FlattenSubQuery(subQueryExpression, fromClause, queryModel);
}
base.VisitMainFromClause(fromClause, queryModel);
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
base.VisitMainFromClause(fromClause, queryModel);
ResultOperatorExpressionRewriter rewriter = new ResultOperatorExpressionRewriter();
fromClause.TransformExpressions(rewriter.Rewrite);
if (fromClause.FromExpression.NodeType == ExpressionType.Constant)
{
System.Type expressionType = queryModel.MainFromClause.FromExpression.Type;
if (expressionType.IsGenericType && expressionType.GetGenericTypeDefinition() == typeof(NhQueryable<>))
{
queryModel.MainFromClause.ItemType = expressionType.GetGenericArguments()[0];
}
}
this.resultOperators.AddRange(rewriter.ResultOperators);
this.evaluationType = rewriter.EvaluationType;
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
var visitor = new HqlGeneratorExpressionTreeVisitor(_parameterAggregator);
visitor.Visit(fromClause.FromExpression);
_fromClause = _hqlTreeBuilder.From(
_hqlTreeBuilder.Range(
visitor.GetHqlTreeNodes().Single(),
_hqlTreeBuilder.Alias(fromClause.ItemName)));
base.VisitMainFromClause(fromClause, queryModel);
}
private Expression CreateAggregate(Expression fromClauseExpression, LambdaExpression body, Func<Expression,Expression> aggregateFactory, Func<ResultOperatorBase> resultOperatorFactory)
{
// TODO - need generated name here
var fromClause = new MainFromClause("x2", body.Parameters[0].Type, fromClauseExpression);
var selectClause = body.Body;
selectClause = ReplacingExpressionTreeVisitor.Replace(body.Parameters[0],
new QuerySourceReferenceExpression(
fromClause), selectClause);
var queryModel = new QueryModel(fromClause,
new SelectClause(aggregateFactory(selectClause)));
// TODO - this sucks, but we use it to get the Type of the SubQueryExpression correct
queryModel.ResultOperators.Add(resultOperatorFactory());
var subQuery = new SubQueryExpression(queryModel);
queryModel.ResultOperators.Clear();
return subQuery;
}
