public Expression ApplyOrderBy(Expression source, OrderByClause orderByClause, out bool isInsertedOrderByMethod)
{
isInsertedOrderByMethod = _isInsertedOrderByMethod;
if (orderByClause == null)
{
return(source);
}
Expression keySelector = null;
if (!_isInsertedOrderByMethod)
{
var tupleProperty = new OePropertyTranslator(source);
_visitor.TuplePropertyByEdmProperty = tupleProperty.Build;
if (OeExpressionHelper.IsTupleType(_visitor.Parameter.Type))
{
var propertyNode = (SingleValuePropertyAccessNode)orderByClause.Expression;
keySelector = tupleProperty.Build(_visitor.Parameter, propertyNode.Property);
}
if (keySelector == null)
{
keySelector = _visitor.TranslateNode(orderByClause.Expression);
}
}
if (keySelector == null)
{
var propertyNode = orderByClause.Expression as SingleValuePropertyAccessNode;
if (propertyNode == null)
{
throw new NotSupportedException("rewrite expression support only sort by property");
}
IEdmType edmSplitType;
if (propertyNode.Source is SingleNavigationNode navigationNode)
{
while (navigationNode.Source is SingleNavigationNode)
{
navigationNode = navigationNode.Source as SingleNavigationNode;
}
edmSplitType = navigationNode.NavigationProperty.DeclaringType;
}
else
{
edmSplitType = propertyNode.Property.DeclaringType;
}
isInsertedOrderByMethod = true;
return(InsertOrderByMethod(source, orderByClause, edmSplitType));
}
return(GetOrderByExpression(source, _visitor.Parameter, orderByClause.Direction, keySelector));
}
private void FindProperty(ReadOnlyCollection <Expression> ctorArguments)
{
for (int i = 0; i < ctorArguments.Count; i++)
{
var propertyExpression = ctorArguments[i] as MemberExpression;
if (propertyExpression == null)
{
var newExpression = ctorArguments[i] as NewExpression;
if (newExpression == null)
{
continue;
}
_expressions.Add(newExpression);
VisitNew(newExpression);
if (_foundProperty != null)
{
return;
}
_expressions.RemoveAt(_expressions.Count - 1);
}
else if (String.Compare(propertyExpression.Member.Name, _edmProperty.Name, StringComparison.OrdinalIgnoreCase) == 0 &&
String.Compare(propertyExpression.Member.DeclaringType.FullName, _edmProperty.DeclaringType.FullTypeName(), StringComparison.OrdinalIgnoreCase) == 0)
{
_foundProperty = _expressions[_expressions.Count - 1].Type.GetProperties()[i];
return;
}
else
{
var tupleVisitor = new OePropertyTranslator(_source);
propertyExpression = tupleVisitor.CreatePropertyExpression(propertyExpression, _edmProperty);
if (propertyExpression != null)
{
_foundProperty = (PropertyInfo)propertyExpression.Member;
_expressions.AddRange(tupleVisitor._expressions);
return;
}
}
}
}
public override SelectItemInfo Translate(PathSelectItem item)
{
SelectItemInfo selectItemInfo;
Expression expression;
if (item.SelectedPath.LastSegment is NavigationPropertySegment navigationSegment)
{
if (_navigationNextLink && navigationSegment.NavigationProperty.Type.Definition is IEdmCollectionType)
{
return(null);
}
selectItemInfo = CreateNavigationSelectItemInfo(_model, navigationSegment, true, null);
PropertyInfo navigationClrProperty = _parameter.Type.GetProperty(selectItemInfo.EdmProperty.Name);
expression = Expression.MakeMemberAccess(_parameter, navigationClrProperty);
}
else if (item.SelectedPath.LastSegment is PropertySegment propertySegment)
{
selectItemInfo = new SelectItemInfo(propertySegment.Property, null);
PropertyInfo property = _parameter.Type.GetProperty(propertySegment.Property.Name);
if (property == null)
{
expression = new OePropertyTranslator(_source).Build(_parameter, propertySegment.Property);
}
else
{
expression = Expression.MakeMemberAccess(_parameter, property);
}
}
else
{
throw new InvalidOperationException(item.SelectedPath.LastSegment.GetType().Name + " not supported");
}
selectItemInfo.Expression = expression;
return(selectItemInfo);
}
private static Expression CreateFilterExpression(Expression source, OeQueryNodeVisitor visitor, bool isDatabaseNullHighestValue, OrderProperty[] orderProperties)
{
var tupleProperty = new OePropertyTranslator(source);
Expression filter = null;
for (int i = 0; i < orderProperties.Length; i++)
{
BinaryExpression eqFilter = null;
for (int j = 0; j < i; j++)
{
MemberExpression propertyExpression = orderProperties[j].PropertyExpression;
ConstantExpression parameterExpression = orderProperties[j].ParmeterExpression;
BinaryExpression eq = Expression.Equal(propertyExpression, parameterExpression);
if (OeExpressionHelper.IsNullable(propertyExpression))
{
UnaryExpression typedNull = Expression.Convert(OeConstantToVariableVisitor.NullConstantExpression, parameterExpression.Type);
BinaryExpression isNull = Expression.Equal(parameterExpression, typedNull);
eq = Expression.OrElse(eq, isNull);
}
eqFilter = eqFilter == null ? eq : Expression.AndAlso(eqFilter, eq);
}
orderProperties[i].PropertyExpression = (MemberExpression)visitor.TranslateNode(orderProperties[i].PropertyNode);
if (orderProperties[i].PropertyExpression == null)
{
orderProperties[i].PropertyExpression = tupleProperty.Build(visitor.Parameter, orderProperties[i].PropertyNode.Property);
}
BinaryExpression ge = CreateBinaryExpression(visitor, isDatabaseNullHighestValue, ref orderProperties[i]);
eqFilter = eqFilter == null ? ge : Expression.AndAlso(eqFilter, ge);
filter = filter == null ? eqFilter : Expression.OrElse(filter, eqFilter);
}
return(filter);
}
public static OePropertyAccessor[] GetAccessors(Expression source, OrderByClause orderByClause)
{
var accessors = new List <OePropertyAccessor>();
var tupleProperty = new OePropertyTranslator(source);
Type itemType = OeExpressionHelper.GetCollectionItemType(source.Type);
ParameterExpression parameter = Expression.Parameter(typeof(Object));
UnaryExpression instance = Expression.Convert(parameter, itemType);
while (orderByClause != null)
{
var propertyNode = (SingleValuePropertyAccessNode)orderByClause.Expression;
MemberExpression propertyExpression = tupleProperty.Build(instance, propertyNode.Property);
if (propertyExpression == null)
{
throw new InvalidOperationException("order by property " + propertyNode.Property.Name + "not found");
}
accessors.Add(OePropertyAccessor.CreatePropertyAccessor(propertyNode.Property, propertyExpression, parameter));
orderByClause = orderByClause.ThenBy;
}
return(accessors.ToArray());
}
