private ProcessingResult ProcessThenBy(MethodCallExpression query, ProcessingResult parentResult, DataContext context, bool descending) { if ((!parentResult.IsDeferred()) && (parentResult.Result is IOrderedQueryable)) { return(ProcessingResult.Unsuccessful); } var keySelector = GetKeySelector(query); var comparer = GetComparer(query); var keysResult = GetKeys(keySelector, parentResult, context); if (!keysResult.IsSuccess) { return(ProcessByDefault(query, parentResult, context)); } var keyType = keySelector.ReturnType; var sourceType = parentResult.IsDeferred() ? typeof(NodeReference) : QueryProcessingHelper.GetSourceParameterType(query); Func <OrderedEnumerable <RuntimeType1>, List <RuntimeType2>, IComparer <RuntimeType2>, bool, OrderedEnumerable <RuntimeType1> > func = AppendOrderedEnumerable; var orderedEnumerable = RuntimeMethodInvoker.InvokeFuncCached(func, new RuntimeTypeBinding { new RuntimeType1(sourceType), new RuntimeType2(keyType) }, parentResult.Result, keysResult.Result, comparer, descending); return(new ProcessingResult(true, orderedEnumerable)); }
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context) { var items = parentResult.GetItems(); var enumerator = items.GetEnumerator(); var count = (int)((ConstantExpression)query.Arguments[1]).Value; var currentIndex = 0; while ((currentIndex < count) && enumerator.MoveNext()) { currentIndex++; } var itemType = parentResult.IsDeferred() ? typeof(NodeReference) : QueryProcessingHelper.GetSourceParameterType(query); var resultList = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(itemType)); while (enumerator.MoveNext()) { resultList.Add(enumerator.Current); } 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)); }
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 ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context) { var itemType = parentResult.IsDeferred() ? typeof(NodeReference) : QueryProcessingHelper.GetSourceParameterType(query); var result = RuntimeMethodInvoker.InvokeFuncCached <IEnumerable <RuntimeType1>, IEnumerable <RuntimeType1> >( Reverse, new RuntimeTypeBinding { new RuntimeType1(itemType) }, parentResult.Result); return(new ProcessingResult(true, result)); }
private static ProcessingResult ProcessByDefault(MethodCallExpression query, ProcessingResult parentResult, DataContext context) { if (!parentResult.IsDeferred()) { return(QueryProcessingHelper.ProcessQueryByDefault(query, parentResult, context)); } Func <IDeferredOrderedEnumerable, IOrderedEnumerable <RuntimeType1> > func = GetLoadedOrderedEnumerable <RuntimeType1>; var loadedEnumerable = RuntimeMethodInvoker.InvokeFuncCached(func, new RuntimeTypeBinding { new RuntimeType1(QueryProcessingHelper.GetSourceParameterType(query)) }, parentResult.Result); return(QueryProcessingHelper.ProcessQueryByDefault(query, new ProcessingResult(true, loadedEnumerable), context)); }
internal static ProcessingResult NormalizeMultipleResult(ProcessingResult result, Type targetItemType) { if (result.IsDeferred()) { return(result); } var sourceItems = result.GetItems(); var resultList = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(targetItemType)); foreach (var sourceItem in sourceItems) { resultList.Add(sourceItem); } return(new ProcessingResult(true, resultList)); }
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)); }
internal static object ProcessQueries(NodeReference node, DataContext context, Expression queryExpression) { var queries = GetQueriesInTurn(queryExpression); var nodes = DatabaseManager.GetEntitiesNodes(node, context); var result = new ProcessingResult(true, nodes); result = queries.Aggregate(result, (current, query) => ProcessQuery(query, current, context)); if (result.IsDeferred()) { return(result.IsSingleItem ? result.GetLoadedItem(GetReturnParameterType(queries.Last())) : result.GetLoadedItems(GetReturnParameterType(queries.Last()))); } return(result.Result); }
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); }
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)); }
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)); }
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)); }