public virtual IParsedLambda Parse(OrderByExpression[] orderByExpressions)
{
Ensure.That(orderByExpressions, "orderByExpressions").HasItems();
var nodesContainer = new NodesCollection();
foreach (var orderByExpression in orderByExpressions.Where(e => e != null))
{
var memberExpression = orderByExpression.InnerLambdaExpression.Body.GetRightMostMember();
if (memberExpression == null)
throw new SisoDbException(ExceptionMessages.OrderByExpressionDoesNotTargetMember.Inject(orderByExpression.ToString()));
var callExpression = (orderByExpression.InnerLambdaExpression.Body is UnaryExpression)
? ((UnaryExpression)orderByExpression.InnerLambdaExpression.Body).Operand as MethodCallExpression
: orderByExpression.InnerLambdaExpression.Body as MethodCallExpression;
if (callExpression != null)
throw new SisoDbException(ExceptionMessages.OrderByParser_UnsupportedMethodForSortingDirection);
var memberType = memberExpression.Type;
if (memberType.IsEnumerableType())
memberType = memberType.GetEnumerableElementType();
var sortDirection = orderByExpression is OrderByAscExpression ? SortDirections.Asc : SortDirections.Desc;
var memberPath = memberExpression.ToPath();
var sortingNode = new SortingNode(memberPath, memberType, DataTypeConverter.Convert(memberType, memberPath), sortDirection);
nodesContainer.AddNode(sortingNode);
}
return new ParsedLambda(nodesContainer.ToArray());
}
public INodesCollection Transform(INodesCollection nodes)
{
var newNodes = new NodesCollection();
var boolType = typeof (bool);
for (var i = 0; i < nodes.Count; i++)
{
var memberNode = nodes[i] as MemberNode;
if(memberNode == null || memberNode.MemberType != boolType)
{
newNodes.AddNode(nodes[i]);
continue;
}
var firstNextNode = nodes.GetItemOrNullByIndex(i + 1) as OperatorNode;
var secondNextNode = nodes.GetItemOrNullByIndex(i + 2) as ValueNode;
var memberNodeIsPartOfCompleteBoolExpression =
firstNextNode != null &&
secondNextNode != null &&
secondNextNode.Value is bool;
if (memberNodeIsPartOfCompleteBoolExpression)
newNodes.AddNode(memberNode);
else
newNodes.AddNodes(memberNode, new OperatorNode(Operator.Equal()), new ValueNode(true));
}
return newNodes;
}
public IParsedLambda Parse(string includedStructureSetName, LambdaExpression[] includeExpressions)
{
Ensure.That(includedStructureSetName, "includedStructureSetName").IsNotNullOrWhiteSpace();
Ensure.That(includeExpressions, "includeExpressions").HasItems();
var nodes = new NodesCollection();
foreach (var includeExpression in includeExpressions)
{
var memberExpression = includeExpression.GetRightMostMember();
var idReferencePath = memberExpression.ToPath();
var objectReferencePath = BuildObjectReferencePath(idReferencePath);
nodes.AddNode(
new IncludeNode(includedStructureSetName, idReferencePath, objectReferencePath, memberExpression.Type));
}
return new ParsedLambda(nodes.ToArray());
}
public virtual IParsedLambda Parse(string includedStructureSetName, LambdaExpression[] includeExpressions)
{
Ensure.That(includedStructureSetName, "includedStructureSetName").IsNotNullOrWhiteSpace();
Ensure.That(includeExpressions, "includeExpressions").HasItems();
var nodes = new NodesCollection();
foreach (var includeExpression in includeExpressions)
{
var memberExpression = includeExpression.GetRightMostMember();
if (memberExpression == null)
throw new SisoDbException(ExceptionMessages.IncludeExpressionDoesNotTargetMember.Inject(includeExpression.ToString()));
var idReferencePath = memberExpression.ToPath();
var objectReferencePath = BuildObjectReferencePath(idReferencePath);
nodes.AddNode(new IncludeNode(
includedStructureSetName, idReferencePath, objectReferencePath, memberExpression.Type, DataTypeConverter.Convert(memberExpression.Type, idReferencePath)));
}
return new ParsedLambda(nodes.ToArray());
}
protected virtual IParsedLambda CreateParsedLambda()
{
//PERF: This ugly processing of nodes for boht transformers in one loop is for performance. Perhaps move bach to older cleaner solution
var nullableNodeTransformer = new NullableNodeTransformer();
var boolNodeTransformer = new BoolNodeTransformer();
var newNodes = new NodesCollection();
var maxIndex = Nodes.Count;
for (var i = 0; i < Nodes.Count; i++)
{
var nullableNodes = nullableNodeTransformer.Transform(maxIndex, ref i, Nodes[i], Nodes);
var merged = nullableNodes.MergeWith(Nodes.Skip(i + 1)).ToArray();
var maxIndexInner = nullableNodes.Length;
for (var iInner = 0; iInner < maxIndexInner; iInner++)
{
var boolNodes = boolNodeTransformer.Transform(maxIndexInner, ref iInner, merged[iInner], new NodesCollection(merged));
newNodes.AddNodes(boolNodes);
}
}
return new ParsedLambda(newNodes.ToArray());
}
public INodesCollection Transform(INodesCollection nodes)
{
if (!nodes.OfType<NullableMemberNode>().Any(n => n.IsForHasValueCheck))
return nodes;
var maxIndex = nodes.Count - 1;
var newNodes = new NodesCollection();
for (var i = 0; i < nodes.Count; i++)
{
var nullableNode = nodes[i] as NullableMemberNode;
if (nullableNode == null || !nullableNode.IsForHasValueCheck)
{
newNodes.AddNode(nodes[i]);
continue;
}
if (i == maxIndex)
{
newNodes.AddNodes(nullableNode, new OperatorNode(Operator.IsNot()), new NullNode());
continue;
}
var rightOperator = nodes[i + 1] as OperatorNode;
var rightValue = nodes[i + 2] as ValueNode;
if (rightOperator == null || rightValue == null)
{
newNodes.AddNodes(nullableNode, new OperatorNode(Operator.IsNot()), new NullNode());
continue;
}
var operatorType = rightOperator.Operator.OperatorType;
var hasValueIs = (bool)rightValue.Value;
var shouldBeIsNotNullNodes =
(operatorType == Operator.Types.Equal && hasValueIs)
|| (operatorType == Operator.Types.NotEqual && hasValueIs == false);
var shouldBeIsNullNodes =
(operatorType == Operator.Types.Equal && hasValueIs == false)
|| (operatorType == Operator.Types.Equal && hasValueIs == false);
if (shouldBeIsNotNullNodes)
{
newNodes.AddNodes(nullableNode, new OperatorNode(Operator.IsNot()), new NullNode());
i += 2;
continue;
}
if (shouldBeIsNullNodes)
{
newNodes.AddNodes(nullableNode, new OperatorNode(Operator.Is()), new NullNode());
i += 2;
continue;
}
}
return newNodes;
}
