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));
}
