public void Replaces_QuerySourceReferenceExpressions ()
{
var expression = new QuerySourceReferenceExpression (_oldFromClause);
var result = ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences (expression, _querySourceMapping, true);
Assert.That (((QuerySourceReferenceExpression) result).ReferencedQuerySource, Is.SameAs (_newFromClause));
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
protected override Expression VisitQuerySourceReference(
QuerySourceReferenceExpression expression)
{
AddQuerySource(expression.ReferencedQuerySource);
return base.VisitQuerySourceReference(expression);
}
public void Resolve_ReplacesParameter_WithProjection ()
{
var node = new SelectManyExpressionNode (
CreateParseInfo(),
_collectionSelector,
ExpressionHelper.CreateLambdaExpression<int, int, AnonymousType> ((a, b) => new AnonymousType (a, b)));
node.Apply (QueryModel, ClauseGenerationContext);
var clause = (FromClauseBase) QueryModel.BodyClauses[0];
var expression = ExpressionHelper.CreateLambdaExpression<AnonymousType, bool> (i => i.a > 5 && i.b > 6);
var result = node.Resolve (expression.Parameters[0], expression.Body, ClauseGenerationContext);
var selectManySourceReference = new QuerySourceReferenceExpression (clause);
// new AnonymousType (SourceReference, selectManySourceReference).a > 5 && new AnonymousType (SourceReference, selectManySourceReference).b > 6
var newAnonymousTypeExpression = Expression.New (
typeof (AnonymousType).GetConstructor (new[] { typeof (int), typeof (int) }), SourceReference, selectManySourceReference);
var anonymousTypeMemberAExpression = Expression.MakeMemberAccess (newAnonymousTypeExpression, typeof (AnonymousType).GetProperty ("a"));
var anonymousTypeMemberBExpression = Expression.MakeMemberAccess (newAnonymousTypeExpression, typeof (AnonymousType).GetProperty ("b"));
var expectedResult = Expression.MakeBinary (
ExpressionType.AndAlso,
Expression.MakeBinary (ExpressionType.GreaterThan, anonymousTypeMemberAExpression, Expression.Constant (5)),
Expression.MakeBinary (ExpressionType.GreaterThan, anonymousTypeMemberBExpression, Expression.Constant (6)));
ExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result);
}
protected internal override Expression VisitQuerySourceReference (QuerySourceReferenceExpression expression)
{
if (_querySourceMapping.ContainsMapping (expression.ReferencedQuerySource))
return _querySourceMapping.GetExpression (expression.ReferencedQuerySource);
return expression;
}
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression)
{
if (!_reachable)
{
if (_originQuerySourceReferenceExpression == null)
{
_originQuerySourceReferenceExpression = expression;
}
if (expression.ReferencedQuerySource.Equals(_targetQuerySource))
{
_reachable = true;
}
else
{
var fromClauseBase = expression.ReferencedQuerySource as FromClauseBase;
if (fromClauseBase != null)
{
VisitExpression(fromClauseBase.FromExpression);
}
}
if (!_reachable)
{
_originQuerySourceReferenceExpression = null;
}
}
return expression;
}
public void GetExpressionMapping ()
{
var querySourceReferenceExpression = new QuerySourceReferenceExpression (_source);
_context.AddExpressionMapping (querySourceReferenceExpression, new SqlTableReferenceExpression (_sqlTable));
Assert.That (
((SqlTableReferenceExpression) _context.GetExpressionMapping (querySourceReferenceExpression)).SqlTable,
Is.SameAs (_sqlTable));
}
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression)
{
if (expression.ReferencedQuerySource == _groupBy)
{
return _groupBy.ElementSelector;
}
return base.VisitQuerySourceReferenceExpression(expression);
}
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression)
{
if (_results.AggregatingClauses.Contains(expression.ReferencedQuerySource as GroupJoinClause))
{
_groupJoin = expression.ReferencedQuerySource as GroupJoinClause;
}
return base.VisitQuerySourceReferenceExpression(expression);
}
protected internal override Expression VisitQuerySourceReference (QuerySourceReferenceExpression expression)
{
ArgumentUtility.CheckNotNull ("expression", expression);
if (_querySourceMapping.ContainsMapping (expression.ReferencedQuerySource))
return _querySourceMapping.GetExpression (expression.ReferencedQuerySource);
return expression;
}
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression)
{
if (_model.FindEntityType(expression.Type) != null)
{
_querySourceReferenceExpressions.Add(expression);
}
return expression;
}
protected override void ModifyFetchQueryModel(QueryModel fetchQueryModel)
{
ArgumentUtility.CheckNotNull<QueryModel>("fetchQueryModel", fetchQueryModel);
System.Linq.Expressions.MemberExpression fromExpression = System.Linq.Expressions.Expression.MakeMemberAccess(new QuerySourceReferenceExpression(fetchQueryModel.MainFromClause), base.RelationMember);
AdditionalFromClause additionalFromClause = new AdditionalFromClause(fetchQueryModel.GetNewName("#fetch"), this._relatedObjectType, fromExpression);
fetchQueryModel.BodyClauses.Add(additionalFromClause);
QuerySourceReferenceExpression selector = new QuerySourceReferenceExpression(additionalFromClause);
SelectClause selectClause = new SelectClause(selector);
fetchQueryModel.SelectClause = selectClause;
}
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression)
{
var innerSelector = GetSubQuerySelectorOrNull(expression);
if (innerSelector != null)
{
return TransparentIdentifierRemovingExpressionTreeVisitor.ReplaceTransparentIdentifiers(VisitExpression(innerSelector));
}
return base.VisitQuerySourceReferenceExpression(expression);
}
public void Initialization ()
{
var referenceExpression = new QuerySourceReferenceExpression (SourceClause);
Assert.That (referenceExpression.Type, Is.SameAs (typeof (int)));
#if !NET_3_5
Assert.That (referenceExpression.NodeType, Is.EqualTo (ExpressionType.Extension));
#else
Assert.That (referenceExpression.NodeType, Is.EqualTo (QuerySourceReferenceExpression.ExpressionType));
#endif
}
public void TryGetExpressiontMappingFromHierarchy ()
{
var querySourceReferenceExpression = new QuerySourceReferenceExpression (_source);
var sqlTableReferenceExpression = new SqlTableReferenceExpression (_sqlTable);
_context.AddExpressionMapping (querySourceReferenceExpression, sqlTableReferenceExpression);
Expression result = _context.GetExpressionMapping (querySourceReferenceExpression);
Assert.That (result, Is.SameAs (sqlTableReferenceExpression));
}
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression)
{
var innerSelector = GetSubQuerySelectorOrNull(expression);
if (innerSelector != null)
{
return VisitExpression(innerSelector);
}
return base.VisitQuerySourceReferenceExpression(expression);
}
public void SetUp ()
{
_mapping = new QuerySourceMapping ();
_clause1 = ExpressionHelper.CreateMainFromClause_Int ();
_clause2 = ExpressionHelper.CreateMainFromClause_Int ();
_clause3 = ExpressionHelper.CreateMainFromClause_Int ();
_querySourceReferenceExpression1 = new QuerySourceReferenceExpression (_clause1);
_querySourceReferenceExpression2 = new QuerySourceReferenceExpression (_clause2);
_querySourceReferenceExpression3 = new QuerySourceReferenceExpression (_clause3);
}
public void TrivialExpression_WithEqualsTrue_ButNotReferenceEquals ()
{
var searchedExpression1 = new QuerySourceReferenceExpression (ExpressionHelper.CreateMainFromClause<Cook>());
var searchedExpression2 = new QuerySourceReferenceExpression (searchedExpression1.ReferencedQuerySource);
var inputParameter = Expression.Parameter (typeof (Cook), "input");
var result = AccessorFindingExpressionTreeVisitor.FindAccessorLambda (searchedExpression1, searchedExpression2, inputParameter);
Expression<Func<Cook, Cook>> expectedResult = input => input;
ExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result);
}
public void Nested()
{
// where this.Convert(r).Name == "x"
var queryRef = new QuerySourceReferenceExpression(new MainFromClause("i", typeof(Record), Expression.Constant("r")));
var call = Expression.Call(Expression.Constant(this), GetType().GetMethod("Convert"), queryRef);
var prop = Expression.Property(call, "Name");
var result = visitor.VisitExpression(prop);
Assert.That(result, Is.EqualTo(new LuceneQueryFieldExpression(typeof(string), "Name")));
}
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression)
{
var propertyInfo = parent.Member as PropertyInfo;
if (propertyInfo == null)
{
throw new NotSupportedException("Only MemberExpression of type PropertyInfo may be used on QuerySourceReferenceExpression.");
}
queryField = new LuceneQueryFieldExpression(propertyInfo.PropertyType, propertyInfo.Name);
return base.VisitQuerySourceReferenceExpression(expression);
}
/// <summary>
/// Modifies the given query model for fetching, adding an <see cref="AdditionalFromClause"/> and changing the <see cref="SelectClause.Selector"/> to
/// retrieve the result of the <see cref="AdditionalFromClause"/>.
/// For example, a fetch request such as <c>FetchMany (x => x.Orders)</c> will be transformed into a <see cref="AdditionalFromClause"/> selecting
/// <c>y.Orders</c> (where <c>y</c> is what the query model originally selected) and a <see cref="SelectClause"/> selecting the result of the
/// <see cref="AdditionalFromClause"/>.
/// This method is called by <see cref="FetchRequestBase.CreateFetchQueryModel"/> in the process of creating the new fetch query model.
/// </summary>
protected override void ModifyFetchQueryModel (QueryModel fetchQueryModel)
{
ArgumentUtility.CheckNotNull ("fetchQueryModel", fetchQueryModel);
var fromExpression = Expression.MakeMemberAccess (new QuerySourceReferenceExpression (fetchQueryModel.MainFromClause), RelationMember);
var memberFromClause = new AdditionalFromClause (fetchQueryModel.GetNewName ("#fetch"), _relatedObjectType, fromExpression);
fetchQueryModel.BodyClauses.Add (memberFromClause);
var newSelector = new QuerySourceReferenceExpression (memberFromClause);
var newSelectClause = new SelectClause (newSelector);
fetchQueryModel.SelectClause = newSelectClause;
}
/// <summary>
/// If the querySource is a subquery, return the SelectClause's selector if it's
/// NewExpression. Otherwise, return null.
/// </summary>
private static NewExpression GetSubQuerySelectorOrNull(QuerySourceReferenceExpression querySource)
{
var fromClause = querySource.ReferencedQuerySource as MainFromClause;
if (fromClause == null)
return null;
var subQuery = fromClause.FromExpression as SubQueryExpression;
if (subQuery == null)
return null;
return subQuery.QueryModel.SelectClause.Selector as NewExpression;
}
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression)
{
var fromClauseBase = expression.ReferencedQuerySource as FromClauseBase;
if (fromClauseBase != null &&
fromClauseBase.FromExpression is QuerySourceReferenceExpression &&
expression.Type == fromClauseBase.FromExpression.Type)
{
return fromClauseBase.FromExpression;
}
return base.VisitQuerySourceReferenceExpression(expression);
}
public virtual EntityTrackingInfo Create(
QueryCompilationContext queryCompilationContext,
QuerySourceReferenceExpression querySourceReferenceExpression,
IEntityType entityType)
{
var trackingInfo = new EntityTrackingInfo(
_keyValueFactorySource,
queryCompilationContext,
querySourceReferenceExpression,
entityType);
return trackingInfo;
}
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression)
{
if (!IsMemberOfModel(expression))
{
return base.VisitQuerySourceReferenceExpression(expression);
}
if (expression.IsGroupingElementOf(_groupBy))
{
return _groupBy.ElementSelector;
}
return base.VisitQuerySourceReferenceExpression(expression);
}
public void Replaces_SubQueryExpressions_WithCorrectCloneContext ()
{
var subQueryModel = ExpressionHelper.CreateQueryModel<Cook> ();
var referencedClause = ExpressionHelper.CreateMainFromClause_Int ();
subQueryModel.SelectClause.Selector = new QuerySourceReferenceExpression (referencedClause);
var expression = new SubQueryExpression (subQueryModel);
var newReferenceExpression = new QuerySourceReferenceExpression (ExpressionHelper.CreateMainFromClause_Int ());
_querySourceMapping.AddMapping (referencedClause, newReferenceExpression);
var result = CloningExpressionTreeVisitor.AdjustExpressionAfterCloning (expression, _querySourceMapping);
var newSubQuerySelectClause = ((SubQueryExpression) result).QueryModel.SelectClause;
Assert.That (newSubQuerySelectClause.Selector, Is.SameAs (newReferenceExpression));
}
public void SetUp ()
{
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
var querySource = ExpressionHelper.CreateMainFromClause<Cook>();
_sqlTable = new SqlTable (new UnresolvedTableInfo (typeof (Cook)), JoinSemantics.Inner);
_context.AddExpressionMapping (new QuerySourceReferenceExpression(querySource), new SqlTableReferenceExpression(_sqlTable));
_querySourceReferenceExpression = new QuerySourceReferenceExpression (querySource);
_stage = new DefaultSqlPreparationStage (
CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), new UniqueIdentifierGenerator());
}
public virtual EntityTrackingInfo Create(
QueryCompilationContext queryCompilationContext,
QuerySourceReferenceExpression querySourceReferenceExpression,
IEntityType entityType)
{
var trackingInfo = new EntityTrackingInfo(
_entityKeyFactorySource,
_clrPropertyGetterSource,
queryCompilationContext,
querySourceReferenceExpression,
entityType);
return trackingInfo;
}
/// <summary>
/// If the querySource is a subquery, return the SelectClause's selector if it's
/// NewExpression. Otherwise, return null.
/// </summary>
private Expression GetSubQuerySelectorOrNull(QuerySourceReferenceExpression expression)
{
if (expression.ReferencedQuerySource != querySource)
return null;
var fromClause = expression.ReferencedQuerySource as FromClauseBase;
if (fromClause == null)
return null;
var subQuery = fromClause.FromExpression as SubQueryExpression;
if (subQuery == null)
return null;
return subQuery.QueryModel.SelectClause.Selector;
}
public virtual QuerySourceReferenceExpression FindResultQuerySourceReferenceExpression(
[NotNull] Expression expression,
[NotNull] IQuerySource targetQuerySource)
{
Check.NotNull(expression, nameof(expression));
Check.NotNull(targetQuerySource, nameof(targetQuerySource));
_targetQuerySource = targetQuerySource;
_originQuerySourceReferenceExpression = null;
_reachable = false;
VisitExpression(expression);
return _reachable ? _originQuerySourceReferenceExpression : null;
}
public void SetUp ()
{
_querySource = ExpressionHelper.CreateMainFromClause_Int ();
_sourceExpression = new QuerySourceReferenceExpression (_querySource);
var originalFunc = ExpressionHelper.CreateLambdaExpression<int, int, int> ((total, i) => total + i);
_func = Expression.Lambda (
ReplacingExpressionTreeVisitor.Replace (originalFunc.Parameters[1], _sourceExpression, originalFunc.Body),
originalFunc.Parameters[0]);
_resultSelector = ExpressionHelper.CreateLambdaExpression<int, string> (total => total.ToString ());
_seed = Expression.Constant (12);
_resultOperatorWithoutResultSelector = new AggregateFromSeedResultOperator (_seed, _func, null);
_resultOperatorWithResultSelector = new AggregateFromSeedResultOperator (_seed, _func, _resultSelector);
}
/// <summary>Visits an Uri property expression called on <see cref="EntityId" />.</summary>
/// <param name="expression">Expression to be visited.</param>
/// <returns>Expression visited</returns>
protected virtual System.Linq.Expressions.Expression VisitEntityIdUri(System.Linq.Expressions.MemberExpression expression)
{
bool isInSelectScenario = (_currentComponent.Count == 0);
StrongEntityAccessor entityAccessor = (isInSelectScenario ? this.GetEntityAccessor(GetMemberTarget(expression)) : this.GetEntityAccessor(GetSourceExpression(expression)));
_query.AddEntityAccessor(entityAccessor);
if (isInSelectScenario)
{
_lastComponent = entityAccessor;
}
else
{
foreach (var entityConstrain in entityAccessor.Elements.OfType <EntityConstrain>())
{
if (entityConstrain.Value is Identifier)
{
Identifier identifier = (Identifier)entityConstrain.Value;
string constrainIdentifier = _query.RetrieveIdentifier(identifier.Name);
string propertyIdentifier = null;
Type propertyType = null;
if (expression.Expression is System.Linq.Expressions.MemberExpression)
{
PropertyInfo propertyInfo = (PropertyInfo)((System.Linq.Expressions.MemberExpression)expression.Expression).Member;
propertyIdentifier = _query.CreateIdentifier(propertyInfo.Name);
propertyType = propertyInfo.PropertyType;
}
else if (expression.Expression is Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression)
{
Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression querySource = (Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression)expression.Expression;
propertyIdentifier = querySource.ReferencedQuerySource.ItemName;
propertyType = querySource.ReferencedQuerySource.ItemType;
}
if ((constrainIdentifier == propertyIdentifier) && (identifier.NativeType == propertyType))
{
_lastComponent = identifier;
break;
}
}
}
if (_lastComponent == null)
{
_lastComponent = entityAccessor.About;
}
HandleComponent(_lastComponent);
}
return(expression);
}
