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)); }
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)); }
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) { var source1 = parentResult.GetLoadedItems(QueryProcessingHelper.GetSourceParameterType(query)); var constantArgument = query.Arguments[1] as ConstantExpression; if (constantArgument == null) { return(ProcessingResult.Unsuccessful); } var source2 = (IEnumerable)constantArgument.Value; var resultElementType = QueryProcessingHelper.GetSourceParameterType(query); var resultList = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(resultElementType)); foreach (var item in source1) { resultList.Add(item); } foreach (var item in source2) { resultList.Add(item); } return(new ProcessingResult(true, resultList)); }
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)); }
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context) { var elementType = QueryProcessingHelper.GetSourceParameterType(query); var items = parentResult.GetLoadedItems(elementType); var comparer = query.Arguments.Count > 1 ? ((ConstantExpression)query.Arguments[1]).Value : null; var result = RuntimeMethodInvoker.InvokeFuncCached <IEnumerable <RuntimeType1>, IEqualityComparer <RuntimeType1>, List <RuntimeType1> >( Distinct, new RuntimeTypeBinding { new RuntimeType1(elementType) }, items, comparer); 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)); }
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context) { var index = (int)((ConstantExpression)query.Arguments[1]).Value; var enumerator = parentResult.GetItems().GetEnumerator(); var elementType = QueryProcessingHelper.GetReturnParameterType(query); while (index >= 0) { if (!enumerator.MoveNext()) { return(new ProcessingResult(true, InstanceCreator.GetDefaultValue(elementType), true)); } index--; } return(new ProcessingResult(true, enumerator.Current, true)); }
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) { var items = parentResult.GetItems(); var enumerator = items.GetEnumerator(); if (enumerator.MoveNext()) { return(new ProcessingResult(true, parentResult.Result)); } var elementType = QueryProcessingHelper.GetSourceParameterType(query); var hasDefaultValue = query.Arguments.Count > 1; var defaultValue = hasDefaultValue ? ((ConstantExpression)query.Arguments[1]).Value : InstanceCreator.GetDefaultValue(elementType); var resultList = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(elementType)); resultList.Add(defaultValue); return(new ProcessingResult(true, resultList)); }
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) { var source1 = parentResult.GetLoadedItems(QueryProcessingHelper.GetSourceParameterType(query)); var constantArgument = query.Arguments[1] as ConstantExpression; if (constantArgument == null) { return(ProcessingResult.Unsuccessful); } var source2 = constantArgument.Value; var comparer = query.Arguments.Count > 2 ? ((ConstantExpression)query.Arguments[2]).Value : null; var sourceType = QueryProcessingHelper.GetSourceParameterType(query); Func <MethodCallExpression, IEnumerable <RuntimeType1>, IEnumerable <RuntimeType1>, IEqualityComparer <RuntimeType1>, ProcessingResult> func = ProcessQuery; return((ProcessingResult)RuntimeMethodInvoker.InvokeFuncCached( func, new RuntimeTypeBinding { new RuntimeType1(sourceType) }, query, source1, source2, comparer)); }
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)); }
object IQueryProvider.Execute(Expression expression) { return(QueryProcessingHelper.ProcessQueries(CreateNodeReference(), Context, expression)); }