public override QueryExpression Visit(QueryRootExpression expression)
{
var entitySetPropertyInfo = expression.GetType().GetProperties(false, false).Where(p => p.Name == "UnderlyingEntitySet").Single();
var entitySet = (EntitySet)entitySetPropertyInfo.GetValue(expression, null);
return(CommonQueryBuilder.Root(entitySet));
}
protected override Expression VisitExtension(Expression node)
{
if (node is QueryRootExpression expression)
{
QueryRootExpression = expression;
}
return(base.VisitExtension(node));
}
/// <summary>
/// Builds a constant expression designed to be used in query filters. The constant is one that is likely to return results although
/// results are not guaranteed.
/// </summary>
/// <param name="rootExpression">The <cref>QueryRootExpression</cref> that contains the property used to generate the constant.</param>
/// <param name="propertyPaths">The paths to the property.</param>
/// <returns>A constant expression matching the property's type</returns>
public QueryConstantExpression GetConstantForProperty(QueryRootExpression rootExpression, string[] propertyPaths)
{
var dataRows = this.DataSet[rootExpression.Name].Elements.Cast <QueryStructuralValue>();
IEnumerable <QueryScalarValue> propertyDataSet =
this.GetPropertyRows(
dataRows,
propertyPaths.ToList <string>(),
((QueryCollectionType <QueryStructuralType>)rootExpression.ExpressionType).ElementType);
return(CommonQueryBuilder.Constant(this.SelectRelevantValue(propertyDataSet)));
}
/// <summary>
/// Resolves types for the specified expression.
/// </summary>
/// <param name="expression">The expression to resolve types for.</param>
/// <returns>Expression with resolved types.</returns>
public QueryExpression Visit(QueryRootExpression expression)
{
EntitySet entitySet = expression.UnderlyingEntitySet;
if (entitySet != null && expression.ExpressionType.IsUnresolved)
{
var expressionType = this.TypeLibrary.GetQueryEntityTypeForEntitySet(entitySet).CreateCollectionType();
return(new QueryRootExpression(entitySet, expressionType));
}
return(expression);
}
protected override Expression VisitExtension(Expression node)
{
if (node is QueryRootExpression queryRootExpression)
{
if (QueryRootExpression != null)
{
throw new InvalidReplaceQueryRootException("more than one query root");
}
QueryRootExpression = queryRootExpression;
}
return(base.VisitExtension(node));
}
/// <summary>
/// Builds root queries
/// </summary>
/// <param name="entityModelSchema">Entity Model Schema</param>
/// <param name="queryTypeLibrary">Query Type Library</param>
protected virtual void BuildRootQueriesAndTypes(EntityModelSchema entityModelSchema, QueryTypeLibrary queryTypeLibrary)
{
var rootQueriesList = new List <QueryExpression>();
foreach (var container in entityModelSchema.EntityContainers)
{
foreach (var entitySet in container.EntitySets)
{
var entityType = queryTypeLibrary.GetQueryEntityTypeForEntitySet(entitySet);
this.RootDataTypes.Add(entitySet.Name, entityType);
if (this.ShouldCreateRootQuery(entitySet))
{
QueryRootExpression rootExpression = new QueryRootExpression(entitySet.Name, entityType.CreateCollectionType());
rootQueriesList.Add(rootExpression);
}
}
}
this.RootQueries = rootQueriesList;
}
protected Expression ExpandNavigation(
Expression root, EntityReference entityReference, INavigation navigation, bool derivedTypeConversion)
{
if (entityReference.NavigationMap.TryGetValue(navigation, out var expansion))
{
return(expansion);
}
var targetType = navigation.TargetEntityType;
if (targetType.HasDefiningNavigation() ||
targetType.IsOwned())
{
var ownedEntityReference = new EntityReference(targetType);
ownedEntityReference.MarkAsOptional();
if (entityReference.IncludePaths.ContainsKey(navigation))
{
ownedEntityReference.SetIncludePaths(entityReference.IncludePaths[navigation]);
}
var ownedExpansion = new OwnedNavigationReference(root, navigation, ownedEntityReference);
if (navigation.IsCollection)
{
var elementType = ownedExpansion.Type.TryGetSequenceType();
var subquery = Expression.Call(
QueryableMethods.AsQueryable.MakeGenericMethod(elementType),
ownedExpansion);
return(new MaterializeCollectionNavigationExpression(subquery, navigation));
}
entityReference.NavigationMap[navigation] = ownedExpansion;
return(ownedExpansion);
}
var innerQueryable = new QueryRootExpression(targetType);
var innerSource = (NavigationExpansionExpression)_navigationExpandingExpressionVisitor.Visit(innerQueryable);
if (entityReference.IncludePaths.ContainsKey(navigation))
{
var innerEntityReference = (EntityReference)((NavigationTreeExpression)innerSource.PendingSelector).Value;
innerEntityReference.SetIncludePaths(entityReference.IncludePaths[navigation]);
}
var innerSourceSequenceType = innerSource.Type.GetSequenceType();
var innerParameter = Expression.Parameter(innerSourceSequenceType, "i");
Expression outerKey;
if (root is NavigationExpansionExpression innerNavigationExpansionExpression &&
innerNavigationExpansionExpression.CardinalityReducingGenericMethodInfo != null)
{
// This is FirstOrDefault ending so we need to push down properties.
var temporaryParameter = Expression.Parameter(root.Type);
var temporaryKey = temporaryParameter.CreateKeyValuesExpression(
navigation.IsOnDependent
? navigation.ForeignKey.Properties
: navigation.ForeignKey.PrincipalKey.Properties,
makeNullable: true);
var newSelector = ReplacingExpressionVisitor.Replace(
temporaryParameter,
innerNavigationExpansionExpression.PendingSelector,
temporaryKey);
innerNavigationExpansionExpression.ApplySelector(newSelector);
outerKey = innerNavigationExpansionExpression;
}
/// <summary>
/// Visits a QueryExpression tree whose root node is the LinqQueryRootExpression.
/// </summary>
/// <param name="expression">The root node of the expression tree being visited.</param>
/// <returns>Uri query string representing the expression.</returns>
public override string Visit(QueryRootExpression expression)
{
return expression.Name;
}
/// <summary>
/// Visits a QueryExpression tree whose root node is the QueryRootExpression.
/// </summary>
/// <param name="expression">The root node of the expression tree being visited.</param>
/// <returns>Uri query string representing the expression.</returns>
public virtual string Visit(QueryRootExpression expression)
{
throw new TaupoNotSupportedException("Not supported");
}
/// <summary>
/// Builds root queries
/// </summary>
/// <param name="entityModelSchema">Entity Model Schema</param>
/// <param name="queryTypeLibrary">Query Type Library</param>
protected virtual void BuildRootQueriesAndTypes(EntityModelSchema entityModelSchema, QueryTypeLibrary queryTypeLibrary)
{
var rootQueriesList = new List<QueryExpression>();
foreach (var container in entityModelSchema.EntityContainers)
{
foreach (var entitySet in container.EntitySets)
{
var entityType = queryTypeLibrary.GetQueryEntityTypeForEntitySet(entitySet);
this.RootDataTypes.Add(entitySet.Name, entityType);
if (this.ShouldCreateRootQuery(entitySet))
{
QueryRootExpression rootExpression = new QueryRootExpression(entitySet.Name, entityType.CreateCollectionType());
rootQueriesList.Add(rootExpression);
}
}
}
this.RootQueries = rootQueriesList;
}
public override QueryExpression Visit(QueryRootExpression expression)
{
var entitySetPropertyInfo = expression.GetType().GetProperties(false, false).Where(p => p.Name == "UnderlyingEntitySet").Single();
var entitySet = (EntitySet)entitySetPropertyInfo.GetValue(expression, null);
return CommonQueryBuilder.Root(entitySet);
}
/// <summary>
/// Generates System.CodeDom.CodeExpression from the given expression.
/// </summary>
/// <param name="expression">Expression from which System.CodeDom.CodeExpression is generated.</param>
/// <returns>Generated System.CodeDom.CodeExpression.</returns>
public virtual CodeExpression Visit(QueryRootExpression expression)
{
return(this.RootExpression.Property(expression.Name));
}
/// <summary>
/// Builds a constant expression designed to be used in query filters. The constant is one that is likely to return results although
/// results are not guaranteed.
/// </summary>
/// <param name="rootExpression">The <cref>QueryRootExpression</cref> that contains the property used to generate the constant.</param>
/// <param name="propertyPaths">The paths to the property.</param>
/// <returns>A constant expression matching the property's type</returns>
public QueryConstantExpression GetConstantForProperty(QueryRootExpression rootExpression, string[] propertyPaths)
{
var dataRows = this.DataSet[rootExpression.Name].Elements.Cast<QueryStructuralValue>();
IEnumerable<QueryScalarValue> propertyDataSet =
this.GetPropertyRows(
dataRows,
propertyPaths.ToList<string>(),
((QueryCollectionType<QueryStructuralType>)rootExpression.ExpressionType).ElementType);
return CommonQueryBuilder.Constant(this.SelectRelevantValue(propertyDataSet));
}
private QueryRootExpressionReplaceVisitor(QueryRootExpression setQuery)
{
_setQuery = setQuery;
}
/// <summary>
/// Visits a QueryExpression tree whose root node is the LinqQueryRootExpression.
/// </summary>
/// <param name="expression">The root node of the expression tree being visited.</param>
/// <returns>Uri query string representing the expression.</returns>
public override string Visit(QueryRootExpression expression)
{
return(expression.Name);
}
/// <summary>
/// Replaces the given expression.
/// </summary>
/// <param name="expression">Expression to replace.</param>
/// <returns>Replaced expression.</returns>
public virtual QueryExpression Visit(QueryRootExpression expression)
{
return(expression);
}
/// <summary>
/// Evaluates the specified expression.
/// </summary>
/// <param name="expression">The expression to evaluate.</param>
/// <returns>Value of the expression.</returns>
public QueryValue Visit(QueryRootExpression expression)
{
return(this.DataSet[expression.Name]);
}
