private static OeEntryFactory CreateEntryFactory(OeSelectItem root, Type clrType)
{
ParameterExpression parameter = Expression.Parameter(typeof(Object));
UnaryExpression typedParameter = Expression.Convert(parameter, clrType);
if (root.HasNavigationItems)
{
List <OeSelectItem> navigationItems = FlattenNavigationItems(root, false);
IReadOnlyList <MemberExpression> navigationProperties = OeExpressionHelper.GetPropertyExpressions(typedParameter);
for (int i = navigationItems.Count - 1; i >= 0; i--)
{
OeSelectItem navigationItem = navigationItems[i];
OeEntryFactory[] nestedNavigationLinks = GetNestedNavigationLinks(navigationItem);
OeEntryFactory entryFactory;
OePropertyAccessor[] accessors = GetAccessors(navigationProperties[i].Type, navigationItem.EntitySet, navigationItem.SelectItems);
Func <Object, Object> linkAccessor = (Func <Object, Object>)Expression.Lambda(navigationProperties[i], parameter).Compile();
if (i == 0)
{
entryFactory = OeEntryFactory.CreateEntryFactoryParent(navigationItem.EntitySet, accessors, nestedNavigationLinks, linkAccessor);
}
else
{
var resourceInfo = new ODataNestedResourceInfo()
{
IsCollection = navigationItem.EdmProperty.Type.Definition is EdmCollectionType,
Name = navigationItem.EdmProperty.Name
};
entryFactory = OeEntryFactory.CreateEntryFactoryNested(navigationItem.EntitySet, accessors, resourceInfo, nestedNavigationLinks, linkAccessor);
entryFactory.CountOption = navigationItem.ExpandedNavigationSelectItem.CountOption;
}
navigationItem.EntryFactory = entryFactory;
}
}
else
{
IReadOnlyList <MemberExpression> propertyExpressions = OeExpressionHelper.GetPropertyExpressions(typedParameter);
OePropertyAccessor[] accessors;
if (root.SelectItems.Count == 0)
{
accessors = OePropertyAccessor.CreateFromType(typedParameter.Type, root.EntitySet);
}
else
{
var accessorList = new List <OePropertyAccessor>(root.SelectItems.Count);
for (int i = 0; i < root.SelectItems.Count; i++)
{
OeSelectItem selectItem = root.SelectItems[i];
accessorList.Add(OePropertyAccessor.CreatePropertyAccessor(selectItem.EdmProperty, propertyExpressions[i], parameter, selectItem.SkipToken));
}
accessors = accessorList.ToArray();
}
root.EntryFactory = OeEntryFactory.CreateEntryFactory(root.EntitySet, accessors);
}
return(root.EntryFactory);
}
private MethodCallExpression ApplyAggregate(Expression source, AggregateTransformationNode transformation)
{
Type sourceType = OeExpressionHelper.GetCollectionItemType(source.Type);
ParameterExpression sourceParameter = Expression.Parameter(sourceType);
ParameterExpression lambdaParameter = sourceParameter;
var expressions = new List <Expression>();
bool isGroupBy = sourceType.GetGenericTypeDefinition() == typeof(IGrouping <,>);
if (isGroupBy)
{
PropertyInfo keyProperty = sourceType.GetProperty(nameof(IGrouping <Object, Object> .Key));
MemberExpression key = Expression.Property(sourceParameter, keyProperty);
expressions.Add(key);
lambdaParameter = Expression.Parameter(sourceType.GetGenericArguments()[1]);
}
var visitor = CreateVisitor(lambdaParameter);
foreach (AggregateExpressionBase aggExpressionBase in transformation.AggregateExpressions)
{
if (aggExpressionBase is AggregateExpression aggExpression)
{
LambdaExpression aggLambda = null;
if (aggExpression.Expression.Kind != QueryNodeKind.Count)
{
Expression expression = visitor.TranslateNode(aggExpression.Expression);
if (isGroupBy && expression is MemberExpression propertyExpression)
{
MemberExpression keyPropertyExpression = FindInGroupByKey(source, expressions[0], propertyExpression);
if (keyPropertyExpression != null)
{
expression = keyPropertyExpression;
}
}
aggLambda = Expression.Lambda(expression, lambdaParameter);
}
MethodCallExpression aggCallExpression = AggCallExpression(aggExpression.Method, sourceParameter, aggLambda);
expressions.Add(aggCallExpression);
_aggProperties.Add(CreateEdmProperty(visitor.EdmModel, aggCallExpression.Type, aggExpression.Alias, false));
}
else
{
throw new NotSupportedException("Unknown aggregate expression type " + aggExpressionBase.GetType().Name);
}
}
NewExpression newExpression = OeExpressionHelper.CreateTupleExpression(expressions);
MethodInfo selectMethodInfo = OeMethodInfoHelper.GetSelectMethodInfo(sourceType, newExpression.Type);
LambdaExpression lambda = Expression.Lambda(newExpression, sourceParameter);
return(Expression.Call(selectMethodInfo, source, lambda));
}
protected override Object CreateEntity(ODataResourceBase resource, IReadOnlyList <NavigationInfo> navigationProperties)
{
Db.OeEntitySetAdapter entitySetAdapter = TestHelper.FindEntitySetAdapterByTypeName(EntitySetAdapters, resource.TypeName);
Type entityType = entitySetAdapter.EntityType;
var openType = (SortedDictionary <String, Object>)CreateEntity(entityType, resource);
Dictionary <PropertyInfo, NavigationInfo> propertyInfos = null;
foreach (NavigationInfo navigationInfo in navigationProperties)
{
Object value = navigationInfo.Value;
if (navigationInfo.Count != null || navigationInfo.NextPageLink != null)
{
PropertyInfo clrProperty = entityType.GetProperty(navigationInfo.Name);
if (value == null && navigationInfo.NextPageLink != null)
{
if (navigationInfo.IsCollection)
{
value = new List <SortedDictionary <String, Object> >();
}
else
{
value = new SortedDictionary <String, Object>();
}
}
base.NavigationProperties.Add(value, navigationInfo);
if (propertyInfos == null)
{
propertyInfos = new Dictionary <PropertyInfo, NavigationInfo>(navigationProperties.Count);
base.NavigationInfoEntities.Add(openType, propertyInfos);
}
propertyInfos.Add(clrProperty, navigationInfo);
}
if (value == null)
{
PropertyInfo clrProprety = entityType.GetProperty(navigationInfo.Name);
Type type = OeExpressionHelper.GetCollectionItemTypeOrNull(clrProprety.PropertyType);
if (type == null)
{
type = clrProprety.PropertyType;
}
if (OeExpressionHelper.IsEntityType(type))
{
value = DBNull.Value;
}
}
openType.Add(navigationInfo.Name, value);
}
return(openType);
}
private static MethodCallExpression CreateWhereExpression(ParameterExpression sourceParameter, Expression subquery, IEdmNavigationProperty edmNavigationProperty)
{
Type subqueryType = OeExpressionHelper.GetCollectionItemType(subquery.Type);
var subqueryParameter = Expression.Parameter(subqueryType, subqueryType.Name);
BinaryExpression joinExpression = GetJoinExpression(sourceParameter, subqueryParameter, edmNavigationProperty);
LambdaExpression predicate = Expression.Lambda(joinExpression, subqueryParameter);
MethodInfo whereMethodInfo = OeMethodInfoHelper.GetWhereMethodInfo(subqueryType);
return(Expression.Call(whereMethodInfo, subquery, predicate));
}
public IAsyncEnumerable <T> ExecuteReader <T>(IQueryable?source = null, CancellationToken cancellationToken = default)
{
IAsyncEnumerable <Object> asyncEnumerable = GetAsyncEnumerator(source);
if (OeExpressionHelper.IsPrimitiveType(typeof(T)) || _queryContext == null || (_queryContext.EntryFactory != null && !_queryContext.EntryFactory.IsTuple))
{
return(Infrastructure.AsyncEnumeratorHelper.ToAsyncEnumerable <T>(asyncEnumerable, cancellationToken));
}
return(new Db.OeEntityAsyncEnumeratorAdapter <T>(asyncEnumerable.GetAsyncEnumerator(), _queryContext));
}
public IAsyncEnumerable <T> ExecuteReader <T>(IQueryable source = null, bool navigationNextLink = false, int?maxPageSize = null)
{
OeAsyncEnumerator asyncEnumerator = GetAsyncEnumerator(source, navigationNextLink, maxPageSize);
if (asyncEnumerator is OeAsyncEnumeratorAdapter || OeExpressionHelper.IsPrimitiveType(typeof(T)))
{
return(new OeAsyncEnumeratorAdapter <T>(asyncEnumerator));
}
return(new OeEntityAsyncEnumeratorAdapter <T>(asyncEnumerator, _queryContext));
}
public virtual PropertyInfo[] GetPrincipalToDependentWithoutDependent(PropertyInfo propertyInfo)
{
Type itemType = OeExpressionHelper.GetCollectionItemTypeOrNull(propertyInfo.PropertyType);
if (itemType != null && GetInverseProperty(propertyInfo) == null)
{
String dependentPropertyName = propertyInfo.DeclaringType.Name + "id";
return(new PropertyInfo[] { itemType.GetPropertyIgnoreCase(dependentPropertyName) });
}
return(null);
}
public IAsyncEnumerable <T> ExecuteReader <T>(IQueryable source = null)
{
IAsyncEnumerable <Object> asyncEnumerable = GetAsyncEnumerator(source);
if (OeExpressionHelper.IsPrimitiveType(typeof(T)) || !_queryContext.EntryFactory.IsTuple)
{
return(Infrastructure.AsyncEnumeratorHelper.ToAsyncEnumerable <T>(asyncEnumerable));
}
return(new Db.OeEntityAsyncEnumeratorAdapter <T>(asyncEnumerable.GetEnumerator(), _queryContext));
}
protected override Expression VisitNew(NewExpression node)
{
ReadOnlyCollection <Expression> arguments = base.Visit(node.Arguments);
if (arguments == node.Arguments)
{
return(node);
}
return(OeExpressionHelper.CreateTupleExpression(arguments));
}
public virtual PropertyInfo[] GetPrincipalToDependentWithoutDependent(PropertyInfo principalNavigation)
{
Type?itemType = OeExpressionHelper.GetCollectionItemTypeOrNull(principalNavigation.PropertyType);
if (itemType != null && GetInverseProperty(principalNavigation) == null)
{
String dependentPropertyName = principalNavigation.DeclaringType !.Name + "id";
return(new PropertyInfo[] { itemType.GetPropertyIgnoreCase(dependentPropertyName) });
}
throw new InvalidOperationException("Pricipal structurlal property not found for principal navigation " + principalNavigation.Name);
}
private MethodCallExpression ApplyGroupBy(Expression source, GroupByTransformationNode transformation)
{
Type sourceType = OeExpressionHelper.GetCollectionItemType(source.Type);
ParameterExpression sourceParameter = Expression.Parameter(sourceType);
var visitor = CreateVisitor(sourceParameter);
var expressions = new List <Expression>();
foreach (GroupByPropertyNode node in transformation.GroupingProperties)
{
if (node.ChildTransformations != null && node.ChildTransformations.Count > 0)
{
for (int i = 0; i < node.ChildTransformations.Count; i++)
{
Expression e = visitor.TranslateNode(node.ChildTransformations[i].Expression);
expressions.Add(e);
String aliasName = node.Name + "_" + node.ChildTransformations[i].Name;
_aggProperties.Add(CreateEdmProperty(visitor.EdmModel, e.Type, aliasName, true));
}
}
else
{
Expression e = visitor.TranslateNode(node.Expression);
expressions.Add(e);
_aggProperties.Add(CreateEdmProperty(visitor.EdmModel, e.Type, node.Name, true));
}
}
NewExpression newExpression = OeExpressionHelper.CreateTupleExpression(expressions);
LambdaExpression lambda = Expression.Lambda(newExpression, sourceParameter);
MethodInfo groupByMethodInfo = OeMethodInfoHelper.GetGroupByMethodInfo(sourceType, newExpression.Type);
MethodCallExpression groupByCall = Expression.Call(groupByMethodInfo, source, lambda);
var aggTransformation = (AggregateTransformationNode)transformation.ChildTransformations;
if (aggTransformation == null)
{
expressions.Clear();
sourceType = OeExpressionHelper.GetCollectionItemType(groupByCall.Type);
sourceParameter = Expression.Parameter(sourceType);
expressions.Add(Expression.Property(sourceParameter, nameof(IGrouping <Object, Object> .Key)));
newExpression = OeExpressionHelper.CreateTupleExpression(expressions);
MethodInfo selectMethodInfo = OeMethodInfoHelper.GetSelectMethodInfo(sourceType, newExpression.Type);
lambda = Expression.Lambda(newExpression, sourceParameter);
return(Expression.Call(selectMethodInfo, groupByCall, lambda));
}
return(ApplyAggregate(groupByCall, aggTransformation));
}
public virtual PropertyInfo?GetInverseProperty(PropertyInfo propertyInfo)
{
var inverse = (InversePropertyAttribute?)propertyInfo.GetCustomAttribute(typeof(InversePropertyAttribute));
if (inverse == null)
{
return(null);
}
Type clrType = OeExpressionHelper.GetCollectionItemTypeOrNull(propertyInfo.PropertyType) ?? propertyInfo.PropertyType;
return(clrType.GetPropertyIgnoreCase(inverse.Property));
}
public ODataResult <T> OData <T>(IAsyncEnumerable <T> asyncEnumerable)
{
IAsyncEnumerator <T> asyncEnumerator = asyncEnumerable.GetEnumerator();
_httpContext.Response.RegisterForDispose(asyncEnumerator);
if (OeExpressionHelper.IsPrimitiveType(typeof(T)) || _queryContext.ODataUri.Path.LastSegment is CountSegment)
{
return(new ODataPrimitiveResult <T>(_edmModel, _odataUri, asyncEnumerator));
}
return(new ODataResult <T>(_queryContext, asyncEnumerator));
}
private void WriteNavigationProperty(ODataWriter writer, Object value, PropertyInfo navigationProperty)
{
Object navigationValue = navigationProperty.GetValue(value);
if (!_stack.Add(navigationValue))
{
return;
}
bool isCollection = OeExpressionHelper.GetCollectionItemType(navigationProperty.PropertyType) != null;
var resourceInfo = new ODataNestedResourceInfo()
{
IsCollection = isCollection,
Name = navigationProperty.Name
};
writer.WriteStart(resourceInfo);
if (navigationValue == null)
{
if (isCollection)
{
writer.WriteStart(new ODataResourceSet());
}
else
{
writer.WriteStart((ODataResource)null);
}
writer.WriteEnd();
}
else
{
var entityPropertiesInfo = default(EntityPropertiesInfo);
if (isCollection)
{
writer.WriteStart(new ODataResourceSet());
foreach (Object entity in (IEnumerable)navigationValue)
{
WriteEntry(writer, entity, ref entityPropertiesInfo);
}
writer.WriteEnd();
}
else
{
WriteEntry(writer, navigationValue, ref entityPropertiesInfo);
}
}
writer.WriteEnd();
_stack.Remove(navigationValue);
}
private static void SetNavigationProperty(OeEntryFactory navigationLink, Object value, Object ownerEntry)
{
PropertyInfo propertyInfo = ownerEntry.GetType().GetProperty(navigationLink.ResourceInfo.Name);
Type nestedEntityType = OeExpressionHelper.GetCollectionItemType(propertyInfo.PropertyType);
if (nestedEntityType == null)
{
nestedEntityType = propertyInfo.PropertyType;
}
Object navigationValue = CreateNestedEntity(navigationLink, value, nestedEntityType);
propertyInfo.SetValue(ownerEntry, navigationValue);
}
private static async Task SetNavigationProperty(Db.OeDbEnumerator dbEnumerator, Object value, Object entity)
{
PropertyInfo propertyInfo = entity.GetType().GetProperty(dbEnumerator.EntryFactory.ResourceInfo.Name);
Type nestedEntityType = OeExpressionHelper.GetCollectionItemType(propertyInfo.PropertyType);
if (nestedEntityType == null)
{
nestedEntityType = propertyInfo.PropertyType;
}
Object navigationValue = await CreateNestedEntity(dbEnumerator, value, nestedEntityType).ConfigureAwait(false);
propertyInfo.SetValue(entity, navigationValue);
}
private static Type ChangeType(Type type)
{
if (type == typeof(DateTimeOffset))
{
return(typeof(DateTime));
}
if (type == typeof(DateTimeOffset?))
{
return(typeof(DateTime?));
}
if (type == typeof(Decimal))
{
return(typeof(double));
}
if (type == typeof(Decimal?))
{
return(typeof(double?));
}
Type[] arguments;
if (OeExpressionHelper.IsTupleType(type))
{
arguments = OeExpressionHelper.GetTupleArguments(type);
}
else if (IsAnonymousType(type))
{
PropertyInfo[] properties = type.GetProperties();
arguments = new Type[properties.Length];
for (int i = 0; i < arguments.Length; i++)
{
arguments[i] = properties[i].PropertyType;
}
}
else
{
return(type);
}
bool changed = false;
for (int i = 0; i < arguments.Length; i++)
{
Type argumentType = ChangeType(arguments[i]);
changed |= argumentType != arguments[i];
arguments[i] = argumentType;
}
return(changed ? OeExpressionHelper.GetTupleType(arguments) : type);
}
private Expression GetInnerSource(OeNavigationSelectItem navigationItem)
{
if (navigationItem.Parent == null)
{
throw new InvalidOperationException("Inner source cannot exist for root item");
}
Type clrEntityType = _edmModel.GetClrType(navigationItem.EdmProperty.DeclaringType);
PropertyInfo navigationClrProperty = clrEntityType.GetPropertyIgnoreCase(navigationItem.EdmProperty);
Type itemType = OeExpressionHelper.GetCollectionItemTypeOrNull(navigationClrProperty.PropertyType) ?? navigationClrProperty.PropertyType;
var visitor = new OeQueryNodeVisitor(_joinBuilder.Visitor, Expression.Parameter(itemType));
var expressionBuilder = new OeExpressionBuilder(_joinBuilder, visitor);
IEdmNavigationProperty navigationProperty = navigationItem.EdmProperty;
if (navigationItem.EdmProperty.ContainsTarget)
{
ModelBuilder.ManyToManyJoinDescription joinDescription = _edmModel.GetManyToManyJoinDescription(navigationProperty);
navigationProperty = joinDescription.TargetNavigationProperty;
}
IEdmEntitySet innerEntitySet = OeEdmClrHelper.GetEntitySet(_edmModel, navigationProperty);
Expression innerSource = OeEnumerableStub.CreateEnumerableStubExpression(itemType, innerEntitySet);
ExpandedNavigationSelectItem item = navigationItem.NavigationSelectItem;
innerSource = expressionBuilder.ApplyFilter(innerSource, item.FilterOption);
long?top = GetTop(navigationItem, item.TopOption);
if (top == null && item.SkipOption == null)
{
return(innerSource);
}
OrderByClause orderByClause = item.OrderByOption;
if (navigationItem.PageSize > 0)
{
orderByClause = OeSkipTokenParser.GetUniqueOrderBy(navigationItem.EntitySet, item.OrderByOption, null);
}
var entitySet = (IEdmEntitySet)navigationItem.Parent.EntitySet;
Expression source = OeEnumerableStub.CreateEnumerableStubExpression(navigationClrProperty.DeclaringType, entitySet);
var crossApplyBuilder = new OeCrossApplyBuilder(_edmModel, expressionBuilder);
return(crossApplyBuilder.Build(source, innerSource, navigationItem.Path, orderByClause, item.SkipOption, top));
}
private static async Task <Object> CreateEntity(IOeDbEnumerator dbEnumerator, Object value, Object entity, Type entityType, CancellationToken cancellationToken)
{
if (OeExpressionHelper.IsTupleType(entity.GetType()))
{
value = entity;
entity = CreateEntityFromTuple(entityType, entity, dbEnumerator.EntryFactory.Accessors);
}
foreach (OeEntryFactory navigationLink in dbEnumerator.EntryFactory.NavigationLinks)
{
await SetNavigationProperty(dbEnumerator.CreateChild(navigationLink), value, entity, cancellationToken).ConfigureAwait(false);
}
return(entity);
}
public ODataResult <T> OData <T>(IAsyncEnumerable <T> asyncEnumerable)
{
IAsyncEnumerator <T> asyncEnumerator = asyncEnumerable.GetEnumerator();
_httpContext.Response.RegisterForDispose(asyncEnumerator);
if (OeExpressionHelper.IsPrimitiveType(typeof(T)))
{
return(new ODataPrimitiveResult <T>(_edmModel, _odataUri, asyncEnumerator));
}
return(new ODataResult <T>(_edmModel, _queryContext.ODataUri, _queryContext.EntryFactory.EntitySet, asyncEnumerator)
{
Count = (asyncEnumerator as OeAsyncEnumerator)?.Count,
PageSize = _queryContext.PageSize
});
}
private static async Task <Dictionary <String, Object> > CreateEntity(Db.OeDbEnumerator dbEnumerator, Object value, Object entity)
{
if (OeExpressionHelper.IsTupleType(entity.GetType()))
{
value = entity;
}
Dictionary <String, Object> dictionary = CreateEntity(entity, dbEnumerator.EntryFactory.Accessors);
foreach (OeEntryFactory navigationLink in dbEnumerator.EntryFactory.NavigationLinks)
{
await SetNavigationProperty(dbEnumerator.CreateChild(navigationLink), value, dictionary).ConfigureAwait(false);
}
return(dictionary);
}
public static MethodCallExpression Build(Expression outer, Expression inner, ExpandedNavigationSelectItem item, ODataPath odataPath, OeExpressionBuilder expressionBuilder)
{
var segment = (NavigationPropertySegment)item.PathToNavigationProperty.LastSegment;
Type outerType = OeExpressionHelper.GetCollectionItemType(outer.Type);
var outerParameter = Expression.Parameter(outerType, outerType.Name);
Expression subquery = CreateWhereExpression(outerParameter, inner, segment.NavigationProperty);
subquery = expressionBuilder.ApplyOrderBy(subquery, item.OrderByOption);
subquery = expressionBuilder.ApplySkip(subquery, item.SkipOption, odataPath);
subquery = expressionBuilder.ApplyTake(subquery, item.TopOption, odataPath);
Type innerType = OeExpressionHelper.GetCollectionItemType(inner.Type);
MethodInfo selectManyMethdoInfo = OeMethodInfoHelper.GetSelectManyMethodInfo(outerType, innerType);
return(Expression.Call(selectManyMethdoInfo, outer, Expression.Lambda(subquery, outerParameter)));
}
private static Expression GetGroupJoinKeySelector(Expression instance, IEnumerable <IEdmStructuralProperty> structuralProperties)
{
var expressions = new List <MemberExpression>();
foreach (IEdmStructuralProperty edmProperty in structuralProperties)
{
PropertyInfo clrProperty = instance.Type.GetPropertyIgnoreCase(edmProperty);
expressions.Add(Expression.Property(instance, clrProperty));
}
if (expressions.Count == 1)
{
return(expressions[0]);
}
return(OeExpressionHelper.CreateTupleExpression(expressions));
}
public Expression GetTuplePropertyByAliasName(Expression source, SingleValueNode singleValueNode)
{
String aliasName = GetAliasName(singleValueNode);
int i = _aggProperties.FindIndex(p => p.Name == aliasName);
if (_aggProperties[i].IsGroup)
{
return(OeExpressionHelper.GetPropertyExpressions(_aggExpressions[0])[i]);
}
int groupCount;
for (groupCount = 0; groupCount < _aggProperties.Count && _aggProperties[groupCount].IsGroup; groupCount++)
{
}
return(_aggExpressions[i - groupCount]);
}
private MethodCallExpression Build(Expression outerSource, Expression innerSource, IReadOnlyList <IEdmNavigationProperty> joinPath, IEdmNavigationProperty navigationProperty, bool manyToMany)
{
Type outerType = OeExpressionHelper.GetCollectionItemType(outerSource.Type);
Type innerType = OeExpressionHelper.GetCollectionItemType(innerSource.Type);
(LambdaExpression groupJoinOuterKeySelector, LambdaExpression groupJoinInnerKeySelector) = GetJoinKeySelector(outerType, innerType, joinPath, navigationProperty);
LambdaExpression groupJoinResultSelect = GetGroupJoinResultSelector(outerType, innerType, manyToMany);
MethodInfo groupJoinMethodInfo = OeMethodInfoHelper.GetGroupJoinMethodInfo(outerType, innerType, groupJoinOuterKeySelector.ReturnType, groupJoinResultSelect.ReturnType);
MethodCallExpression groupJoinCall = Expression.Call(groupJoinMethodInfo, outerSource, innerSource, groupJoinOuterKeySelector, groupJoinInnerKeySelector, groupJoinResultSelect);
LambdaExpression selectManySource = GetSelectManyCollectionSelector(groupJoinResultSelect);
LambdaExpression selectManyResultSelector = GetSelectManyResultSelector(groupJoinResultSelect);
MethodInfo selectManyMethodInfo = OeMethodInfoHelper.GetSelectManyMethodInfo(groupJoinResultSelect.ReturnType, innerType, selectManyResultSelector.ReturnType);
return(Expression.Call(selectManyMethodInfo, groupJoinCall, selectManySource, selectManyResultSelector));
}
private static OeEntryFactory CreateEntryFactory(IEdmModel edmModel, Expression source, Type entityType, List <AggProperty> _aggProperties)
{
IEdmEntitySet entitySet = OeEdmClrHelper.GetEntitySet(edmModel, entityType);
OePropertyAccessor[] accessors;
if (_aggProperties.Count == 0)
{
accessors = OePropertyAccessor.CreateFromType(entityType, entitySet);
}
else
{
Type sourceItemType = OeExpressionHelper.GetCollectionItemType(source.Type);
int groupIndex = _aggProperties.FindIndex(a => a.IsGroup);
accessors = OePropertyAccessor.CreateFromTuple(sourceItemType, _aggProperties, groupIndex);
}
return(OeEntryFactory.CreateEntryFactory(entitySet, accessors));
}
public ODataResult <T> OData <T>(IAsyncEnumerable <T> asyncEnumerable)
{
IAsyncEnumerator <T> asyncEnumerator = asyncEnumerable.GetAsyncEnumerator();
_httpContext.Response.OnCompleted(() => asyncEnumerator.DisposeAsync().AsTask());
if (_odataUri != null && (OeExpressionHelper.IsPrimitiveType(typeof(T)) || _odataUri.Path.LastSegment is CountSegment))
{
return(new ODataPrimitiveResult <T>(_edmModel, _odataUri, asyncEnumerator));
}
if (_queryContext == null)
{
throw new InvalidOperationException("Must invoke OeAspQueryParser.ExecuteReader");
}
return(new ODataResult <T>(_queryContext, asyncEnumerator));
}
public virtual PropertyDescriptor GetInverseProperty(PropertyDescriptor propertyDescriptor)
{
var inverse = (InversePropertyAttribute)propertyDescriptor.Attributes[typeof(InversePropertyAttribute)];
if (inverse == null)
{
return(null);
}
Type type = OeExpressionHelper.GetCollectionItemType(propertyDescriptor.PropertyType);
if (type == null)
{
type = propertyDescriptor.PropertyType;
}
return(TypeDescriptor.GetProperties(type)[inverse.Property]);
}
protected override Expression VisitNew(NewExpression node)
{
var arguments = new Expression[node.Arguments.Count];
for (int i = 0; i < arguments.Length; i++)
{
Expression argument = base.Visit(node.Arguments[i]);
if (argument is MethodCallExpression call && call.Type.GetTypeInfo().IsGenericType&& call.Type.GetGenericTypeDefinition() == typeof(IOrderedEnumerable <>))
{
Type type = call.Type.GetGenericArguments()[0];
MethodInfo selectMethodInfo = OeMethodInfoHelper.GetSelectMethodInfo(type, type);
ParameterExpression parameter = Expression.Parameter(type);
argument = Expression.Call(selectMethodInfo, call, Expression.Lambda(parameter, parameter));
}
arguments[i] = argument;
}
return(OeExpressionHelper.CreateTupleExpression(arguments));
}
private MethodCallExpression ApplyFilter(Expression source, FilterTransformationNode transformation)
{
Type sourceType = OeExpressionHelper.GetCollectionItemType(source.Type);
ParameterExpression sourceParameter = Expression.Parameter(sourceType);
var visitor = CreateVisitor(sourceParameter);
if (_aggProperties.Count > 0)
{
visitor.TuplePropertyByAliasName = GetTuplePropertyByAliasName;
}
Expression e = visitor.TranslateNode(transformation.FilterClause.Expression);
MethodInfo whereMethodInfo = OeMethodInfoHelper.GetWhereMethodInfo(sourceParameter.Type);
LambdaExpression lambda = Expression.Lambda(e, sourceParameter);
return(Expression.Call(whereMethodInfo, source, lambda));
}