private static ProcessingResult PerformUnaryOperation(UnaryExpression expression, List <NodeReference> references,
DataContext context, Func <dynamic, dynamic> operationResolver)
{
var operandResult = ExpressionProcessingHelper.ProcessExpression(expression.Operand, references, context);
if (!operandResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
if (operandResult.IsSingleItem)
{
var value = operandResult.GetLoadedItem(expression.Operand.Type);
return(new ProcessingResult(true, operationResolver(value), true));
}
var values = operandResult.GetLoadedItems(expression.Operand.Type);
var resultList = new List <object>();
foreach (var value in values)
{
resultList.Add(operationResolver(value));
}
return(new ProcessingResult(true, resultList));
}
protected ProcessingResult GetKeys(LambdaExpression keySelector, ProcessingResult parentResult, DataContext context)
{
if (!parentResult.IsDeferred())
{
var keys = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(keySelector.ReturnType));
var compiledSelector = CompiledExpressionStorage.GetOrAddCompiledLambda(keySelector);
foreach (var item in parentResult.GetItems())
{
keys.Add(compiledSelector.DynamicInvoke(item));
}
return(new ProcessingResult(true, keys));
}
var nodeReferences = parentResult.GetDeferredList();
var keysResult = ExpressionProcessingHelper.ProcessExpression(keySelector.Body, nodeReferences, context);
if (!keysResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
if (keysResult.IsSingleItem)
{
keysResult = ExpressionProcessingHelper.CopyInstances(keysResult, nodeReferences.Count,
() => ExpressionProcessingHelper.ProcessExpression(keySelector.Body, nodeReferences, context).Result);
}
keysResult = new ProcessingResult(true, keysResult.GetLoadedItems(keySelector.ReturnType));
return(QueryProcessingHelper.NormalizeMultipleResult(keysResult, keySelector.ReturnType));
}
private static void EvaluateMemeberAssignment(EvaluatedMemberBinding result, MemberAssignment assignment,
List <NodeReference> references, DataContext context)
{
var processingResult = ExpressionProcessingHelper.ProcessExpression(assignment.Expression, references, context);
result.AddResult(LoadData(processingResult, assignment.Expression.Type));
}
public ProcessingResult ProcessExpression(Expression expression, List <NodeReference> references, DataContext context)
{
var invocationExpression = expression as InvocationExpression;
if (invocationExpression == null)
{
return(ProcessingResult.Unsuccessful);
}
var argumentsResults = CallProcessingHelper.ProcessArguments(invocationExpression.Arguments, references, context);
if (!argumentsResults.All(r => r.IsSuccess))
{
return(ProcessingResult.Unsuccessful);
}
var delegateResult = ExpressionProcessingHelper.ProcessExpression(invocationExpression.Expression, references, context);
if (!delegateResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
return(CallProcessingHelper.ProcessCall(argumentsResults, delegateResult, (del, arguments) =>
{
var delegateInstance = del as Delegate;
return delegateInstance != null
? new ProcessingResult(true, delegateInstance.DynamicInvoke(arguments))
: ProcessingResult.Unsuccessful;
}));
}
public ProcessingResult ProcessExpression(Expression expression, List <NodeReference> references, DataContext context)
{
var memberInitExpression = expression as MemberInitExpression;
if (memberInitExpression == null)
{
return(ProcessingResult.Unsuccessful);
}
var instanceResult = ExpressionProcessingHelper.ProcessExpression(memberInitExpression.NewExpression, references, context);
if (!instanceResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
var evaluatedBindings = MemberBindingEvaluator.EvaluateBindings(memberInitExpression.Bindings.ToList(), references, context);
if (evaluatedBindings.Any(b => !b.IsSuccess))
{
return(ProcessingResult.Unsuccessful);
}
if (instanceResult.IsSingleItem && evaluatedBindings.Any(b => !b.IsSingle))
{
instanceResult = ExpressionProcessingHelper.CopyInstances(instanceResult, references.Count,
() => ExpressionProcessingHelper.ProcessExpression(memberInitExpression.NewExpression, references, context).Result);
}
return(MemberBindingProcessingHelper.ProcessBindings(evaluatedBindings, instanceResult));
}
private static ProcessingResult ProcessArrayIndexExpression(BinaryExpression expression, List <NodeReference> references, DataContext context)
{
var arrayResult = ExpressionProcessingHelper.ProcessExpression(expression.Left, references, context);
if (!arrayResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
var indexResult = ExpressionProcessingHelper.ProcessExpression(expression.Right, references, context);
if (!indexResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
var processingResult = IterateNodesItems(arrayResult, indexResult, ApplyArrayIndex);
var resultData = processingResult.Result;
if (!arrayResult.IsDeferred())
{
return(new ProcessingResult(processingResult.IsSuccess, resultData, processingResult.IsSingleItem));
}
var deferredList = processingResult.GetItems();
if (deferredList != null)
{
resultData = deferredList.Cast <NodeReference>().ToList();
}
return(new ProcessingResult(processingResult.IsSuccess, resultData, processingResult.IsSingleItem));
}
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context)
{
if (!parentResult.IsDeferred())
{
return(ProcessingResult.Unsuccessful);
}
var predicateResult = ExpressionProcessingHelper.ProcessPredicate(query.Arguments[1], parentResult.GetDeferredItems(), context);
return(predicateResult.IsSuccess ? predicateResult : ProcessingResult.Unsuccessful);
}
public ProcessingResult ProcessExpression(Expression expression, List <NodeReference> references, DataContext context)
{
var memberExpression = expression as MemberExpression;
if (memberExpression == null)
{
return(ProcessingResult.Unsuccessful);
}
//getting static member
if (memberExpression.Expression == null)
{
var propertyInfo = memberExpression.Member as PropertyInfo;
if (propertyInfo != null)
{
return(new ProcessingResult(true, propertyInfo.GetValue(null), true));
}
var fieldInfo = memberExpression.Member as FieldInfo;
if (fieldInfo != null)
{
return(new ProcessingResult(true, fieldInfo.GetValue(null), true));
}
return(ProcessingResult.Unsuccessful);
}
var parentResult = ExpressionProcessingHelper.ProcessExpression(memberExpression.Expression, references, context);
if (!parentResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
if (parentResult.IsSingleItem)
{
var item = parentResult.GetLoadedItem(memberExpression.Type);
return(new ProcessingResult(true, ProcessLoadedEntityMember(item, memberExpression), true));
}
var nodes = parentResult.GetDeferredItems();
if (nodes != null)
{
var columnAttribute = memberExpression.Member.GetCustomAttribute <ColumnAttribute>();
return(new ProcessingResult(true, ResolveColumn(columnAttribute, memberExpression, nodes)));
}
var values = parentResult.GetItems();
return(new ProcessingResult(true, ProcessLoadedEntityMembers(values, memberExpression)));
}
public ProcessingResult ProcessExpression(Expression expression, List <NodeReference> references, DataContext context)
{
var conditionalExpression = expression as ConditionalExpression;
if (conditionalExpression == null)
{
return(ProcessingResult.Unsuccessful);
}
var testResult = ExpressionProcessingHelper.ProcessExpression(conditionalExpression.Test, references, context);
if (!testResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
if (testResult.IsSingleItem)
{
var testValue = (bool)testResult.GetLoadedItem(typeof(bool));
var resultExpression = testValue ? conditionalExpression.IfTrue : conditionalExpression.IfFalse;
return(ExpressionProcessingHelper.ProcessExpression(resultExpression, references, context));
}
var resultValues = testResult.GetLoadedItems(typeof(bool));
var results = new List <object>();
var index = 0;
foreach (var resultValue in resultValues)
{
var resultExpression = (bool)resultValue ? conditionalExpression.IfTrue : conditionalExpression.IfFalse;
var processingResult = ExpressionProcessingHelper.ProcessExpression(resultExpression, new List <NodeReference>(1)
{
references[index]
}, context);
if (!processingResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
results.Add(ResolveValue(processingResult, resultExpression.Type));
index++;
}
return(new ProcessingResult(true, results));
}
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context)
{
if (!parentResult.IsDeferred())
{
return(ProcessingResult.Unsuccessful);
}
var predicateExpression = query.Arguments[1];
var items = parentResult.GetItems();
var enumerator = items.GetEnumerator();
var resultList = new List <NodeReference>();
while (enumerator.MoveNext())
{
var predicateResult = ExpressionProcessingHelper.ProcessPredicate(predicateExpression,
new List <NodeReference>(1)
{
(NodeReference)enumerator.Current
}, context);
if (!predicateResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
var predicateValue = ((IList <NodeReference>)predicateResult.Result).Any();
if (predicateValue)
{
ConditionTrueCallback(resultList, enumerator.Current);
continue;
}
ConditionFalseCallback(resultList, enumerator.Current);
break;
}
while (enumerator.MoveNext())
{
ConditionFalseCallback(resultList, enumerator.Current);
}
return(new ProcessingResult(true, resultList));
}
private static void EvaluateListBinding(EvaluatedMemberBinding result, MemberListBinding listBinding,
List <NodeReference> references, DataContext context)
{
foreach (var initializer in listBinding.Initializers)
{
var processingResults = initializer.Arguments
.Select(a => LoadData(ExpressionProcessingHelper.ProcessExpression(a, references, context), a.Type))
.ToList();
if (processingResults.Any(r => !r.IsSuccess))
{
result.MarkUnsuccessful();
return;
}
result.AddInitializer(initializer.AddMethod, processingResults);
}
}
private static ProcessingResult ProcessObjectExpression(Expression objectExpression, List <NodeReference> references, DataContext context)
{
if (objectExpression == null)
{
return(new ProcessingResult(true, null, true));
}
var objectResult = ExpressionProcessingHelper.ProcessExpression(objectExpression, references, context);
if (!objectResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
var value = objectResult.IsSingleItem
? objectResult.GetLoadedItem(objectExpression.Type)
: objectResult.GetLoadedItems(objectExpression.Type);
return(new ProcessingResult(true, value, objectResult.IsSingleItem));
}
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context)
{
var hasPredicate = query.Arguments.Count == 2;
if (!hasPredicate)
{
return(ProcessQuery(parentResult.GetItems().GetEnumerator(), QueryProcessingHelper.GetReturnParameterType(query)));
}
if (!parentResult.IsDeferred())
{
return(ProcessingResult.Unsuccessful);
}
var predicate = query.Arguments[1];
var predicateResult = ExpressionProcessingHelper.ProcessPredicate(predicate, parentResult.GetDeferredItems(), context);
return(predicateResult.IsSuccess
? ProcessQuery(predicateResult.GetItems().GetEnumerator(), QueryProcessingHelper.GetReturnParameterType(query))
: ProcessingResult.Unsuccessful);
}
private static List <EvaluatedListInitializer> EvaluateInitializers(IEnumerable <ElementInit> initializers,
List <NodeReference> references, DataContext context)
{
var result = new List <EvaluatedListInitializer>();
foreach (var initializer in initializers)
{
var processingResults = initializer.Arguments
.Select(a => LoadData(ExpressionProcessingHelper.ProcessExpression(a, references, context), a.Type))
.ToList();
result.Add(new EvaluatedListInitializer(initializer.AddMethod, processingResults));
if (processingResults.Any(r => !r.IsSuccess))
{
break;
}
}
return(result);
}
public ProcessingResult ProcessExpression(Expression expression, List <NodeReference> references, DataContext context)
{
var typeBinaryExpression = expression as TypeBinaryExpression;
if (typeBinaryExpression == null)
{
return(ProcessingResult.Unsuccessful);
}
var result = ExpressionProcessingHelper.ProcessExpression(typeBinaryExpression.Expression, references, context);
if (!result.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
if (result.IsSingleItem)
{
var objectType = result.GetLoadedItem(typeBinaryExpression.Expression.Type).GetType();
return(new ProcessingResult(true, TypeIs(objectType, typeBinaryExpression.TypeOperand), true));
}
if (result.IsDeferred())
{
var objectType = typeBinaryExpression.Expression.Type;
var typeIsResult = TypeIs(objectType, typeBinaryExpression.TypeOperand);
return(new ProcessingResult(true, Enumerable.Repeat(typeIsResult, references.Count).ToList()));
}
var resultList = new List <bool>();
var loadedItems = result.GetLoadedItems(typeBinaryExpression.Expression.Type);
foreach (var loadedItem in loadedItems)
{
resultList.Add(TypeIs(loadedItem.GetType(), typeBinaryExpression.TypeOperand));
}
return(new ProcessingResult(true, resultList));
}
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context)
{
if (!parentResult.IsDeferred())
{
return(ProcessingResult.Unsuccessful);
}
var predicate = query.Arguments[1];
var predicateResult = ExpressionProcessingHelper.ProcessPredicate(predicate, parentResult.GetDeferredItems(), context);
if (!predicateResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
var parentResultCount = parentResult.GetDeferredItems().Count();
var predicateResultCount = predicateResult.GetDeferredItems().Count();
var result = (parentResultCount == predicateResultCount);
return(new ProcessingResult(true, result, true));
}
private static ProcessingResult ProcessExpressionByDefault(BinaryExpression expression, List <NodeReference> references, DataContext context)
{
var leftResult = ExpressionProcessingHelper.ProcessExpression(expression.Left, references, context);
if (!leftResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
var rightResult = ExpressionProcessingHelper.ProcessExpression(expression.Right, references, context);
if (!rightResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
var leftDataType = expression.Left.Type;
var rightDataType = expression.Right.Type;
return(IterateNodesItems(leftResult, rightResult,
(left, right) => PerformBinaryOperation(left, leftDataType, right, rightDataType, expression.NodeType)));
}
public ProcessingResult ProcessExpression(Expression expression, List <NodeReference> references, DataContext context)
{
var listInitExpression = expression as ListInitExpression;
if (listInitExpression == null)
{
return(ProcessingResult.Unsuccessful);
}
var instanceResult = ExpressionProcessingHelper.ProcessExpression(listInitExpression.NewExpression, references, context);
if (instanceResult == null)
{
return(ProcessingResult.Unsuccessful);
}
var evaluatedInitializers = EvaluateInitializers(listInitExpression.Initializers, references, context);
var isSuccess = evaluatedInitializers.All(i => i.Arguments.All(a => a.IsSuccess));
if (!isSuccess)
{
return(ProcessingResult.Unsuccessful);
}
var isSingleInitializers = evaluatedInitializers.All(i => i.Arguments.All(a => a.IsSingleItem));
if (instanceResult.IsSingleItem && !isSingleInitializers)
{
instanceResult = ExpressionProcessingHelper.CopyInstances(instanceResult, references.Count,
() => ExpressionProcessingHelper.ProcessExpression(listInitExpression.NewExpression, references, context).Result);
}
instanceResult = evaluatedInitializers.Aggregate(instanceResult,
(current, initializer) => MemberBindingProcessingHelper.ProcessListInitializer(initializer, current));
return(instanceResult);
}
private static ProcessingResult PerformShortCircuitingOperation(bool left, Expression rightExpression,
NodeReference reference, ExpressionType operationType, DataContext context)
{
if ((operationType == ExpressionType.AndAlso) && (!left))
{
return(new ProcessingResult(true, false, true));
}
if ((operationType == ExpressionType.OrElse) && (left))
{
return(new ProcessingResult(true, true, true));
}
var rightResult = ExpressionProcessingHelper.ProcessExpression(rightExpression,
new List <NodeReference>(1)
{
reference
}, context);
if (!rightResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
if (rightResult.IsSingleItem)
{
return(new ProcessingResult(true, (bool)rightResult.Result, true));
}
var rightValues = rightResult.GetLoadedItems(typeof(bool));
foreach (var rightValue in rightValues)
{
return(new ProcessingResult(true, (bool)rightValue, true));
}
return(ProcessingResult.Unsuccessful);
}
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context)
{
if (!parentResult.IsDeferred())
{
return(ProcessingResult.Unsuccessful);
}
var unaryExpression = (UnaryExpression)query.Arguments[1];
var lambdaExpression = (LambdaExpression)unaryExpression.Operand;
if (lambdaExpression.Parameters.Count > 1)
{
return(ProcessingResult.Unsuccessful);
}
var memberExpression = lambdaExpression.Body;
var nodeReferences = parentResult.GetDeferredList();
var result = ExpressionProcessingHelper.ProcessExpression(memberExpression, nodeReferences, context);
if (!result.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
var targetItemType = QueryProcessingHelper.GetReturnParameterType(query);
if (!result.IsSingleItem)
{
return(QueryProcessingHelper.NormalizeMultipleResult(result, targetItemType));
}
var multipleResult = ExpressionProcessingHelper.CopyInstances(result, nodeReferences.Count,
() => ExpressionProcessingHelper.ProcessExpression(memberExpression, nodeReferences, context).Result);
return(new ProcessingResult(true, QueryProcessingHelper.NormalizeMultipleResult(multipleResult, targetItemType).Result));
}
private static ProcessingResult ProcessShortCircuitingExpression(BinaryExpression expression,
List <NodeReference> references, ExpressionType operationType, DataContext context)
{
if (!(expression.Left.Type == typeof(bool) && expression.Right.Type == typeof(bool)))
{
return(ProcessExpressionByDefault(expression, references, context));
}
var leftResult = ExpressionProcessingHelper.ProcessExpression(expression.Left, references, context);
if (!leftResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
var operationResult = IterateNodesItems(leftResult, new ProcessingResult(true, references),
(left, right) =>
PerformShortCircuitingOperation((bool)left, expression.Right, (NodeReference)right, operationType, context));
var resultList = new List <object>();
if (operationResult.IsSingleItem)
{
return(new ProcessingResult(true, (bool)operationResult.Result, true));
}
foreach (ProcessingResult item in operationResult.GetItems())
{
if (!item.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
resultList.Add((bool)item.Result);
}
return(new ProcessingResult(true, resultList));
}
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context)
{
if (!parentResult.IsDeferred())
{
return(ProcessingResult.Unsuccessful);
}
var hasSelector = query.Arguments.Count > 1;
var elementType = QueryProcessingHelper.GetReturnParameterType(query);
if (!hasSelector)
{
var items = parentResult.GetLoadedItems(elementType);
return(new ProcessingResult(true, ProcessQuery(items), true));
}
var unaryExpression = (UnaryExpression)query.Arguments[1];
var selectorLambda = (LambdaExpression)unaryExpression.Operand;
var selectorResult = ExpressionProcessingHelper.ProcessExpression(selectorLambda.Body, parentResult.GetDeferredList(), context);
if (!selectorResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
if (selectorResult.IsSingleItem)
{
var result = Convert.ChangeType(selectorResult.Result, elementType);
return(new ProcessingResult(true, result, true));
}
var loadedItems = selectorResult.GetLoadedItems(elementType);
return(new ProcessingResult(true, ProcessQuery(loadedItems), true));
}
private static ProcessingResult ProcessArrayLengthExpression(UnaryExpression expression, List <NodeReference> references, DataContext context)
{
var parentResult = ExpressionProcessingHelper.ProcessExpression(expression.Operand, references, context);
if (!parentResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
if (parentResult.IsSingleItem)
{
var deferredResult = parentResult.GetDeferredItem();
return(deferredResult != null
? new ProcessingResult(true, DatabaseManager.GetEnumerableCount(deferredResult), true)
: new ProcessingResult(true, ((Array)parentResult.Result).Length, true));
}
var deferredItems = parentResult.GetDeferredItems();
if (deferredItems != null)
{
var resultList = deferredItems.Select(DatabaseManager.GetEnumerableCount).ToList();
return(new ProcessingResult(true, resultList));
}
var resultItems = parentResult.GetItems();
var result = new List <object>();
foreach (var resultItem in resultItems)
{
var array = (Array)resultItem;
result.Add(array.Length);
}
return(new ProcessingResult(true, result));
}
