private Func <T, bool> BuildFunctionFromNode <T>(IQueryNode node, QueryEngine <T> engine, ICollection <QueryError> errors)
{
Func <T, bool> noOp = o => false;
if (node == null)
{
return(noOp);
}
switch (node.type)
{
case QueryNodeType.And:
{
Assert.IsFalse(node.leaf, "And node cannot be leaf.");
var leftFunc = BuildFunctionFromNode(node.children[0], engine, errors);
var rightFunc = BuildFunctionFromNode(node.children[1], engine, errors);
return(o => leftFunc(o) && rightFunc(o));
}
case QueryNodeType.Or:
{
Assert.IsFalse(node.leaf, "Or node cannot be leaf.");
var leftFunc = BuildFunctionFromNode(node.children[0], engine, errors);
var rightFunc = BuildFunctionFromNode(node.children[1], engine, errors);
return(o => leftFunc(o) || rightFunc(o));
}
case QueryNodeType.Not:
{
Assert.IsFalse(node.leaf, "Not node cannot be leaf.");
var childFunc = BuildFunctionFromNode(node.children[0], engine, errors);
return(o => !childFunc(o));
}
case QueryNodeType.Filter:
{
var filterNode = node as FilterNode;
if (filterNode == null)
{
return(noOp);
}
var filterOperation = GenerateFilterOperation(filterNode, engine, errors);
if (filterOperation == null)
{
return(noOp);
}
return(o => filterOperation.Match(o));
}
case QueryNodeType.Search:
{
if (engine.searchDataCallback == null)
{
return(o => false);
}
var searchNode = node as SearchNode;
Assert.IsNotNull(searchNode);
Func <string, bool> matchWordFunc;
var stringComparison = engine.globalStringComparison;
if (engine.searchDataOverridesStringComparison)
{
stringComparison = engine.searchDataStringComparison;
}
if (searchNode.exact)
{
matchWordFunc = s => s.Equals(searchNode.searchValue, stringComparison);
}
else
{
matchWordFunc = s => s.IndexOf(searchNode.searchValue, stringComparison) >= 0;
}
return(o => engine.searchDataCallback(o).Any(data => matchWordFunc(data)));
}
case QueryNodeType.In:
{
var filterNode = node as InFilterNode;
if (filterNode == null)
{
return(noOp);
}
var filterOperation = GenerateFilterOperation(filterNode, engine, errors);
if (filterOperation == null)
{
return(noOp);
}
var inFilterFunction = GenerateInFilterFunction(filterNode, filterOperation, engine, errors);
return(inFilterFunction);
}
}
return(noOp);
}
private Func <T, bool> GenerateInFilterFunctionWithTypes <T, TNested, TTransform>(InFilterNode node, BaseFilterOperation <T> filterOperation, QueryEngine <T> engine, ICollection <QueryError> errors)
{
var nestedQueryEnumerable = EnumerableCreator.Create <TNested>(node.children[0], null, errors);
if (nestedQueryEnumerable == null)
{
return(null);
}
var nestedQueryTransformer = node.filter.queryHandlerTransformer as NestedQueryHandlerTransformer <TNested, TTransform>;
if (nestedQueryTransformer == null)
{
return(null);
}
var transformerFunction = nestedQueryTransformer.handler;
var dynamicFilterOperation = filterOperation as IDynamicFilterOperation <TTransform>;
if (dynamicFilterOperation == null)
{
return(null);
}
return(o =>
{
foreach (var item in nestedQueryEnumerable)
{
var transformedValue = transformerFunction(item);
dynamicFilterOperation.SetFilterValue(transformedValue);
if (filterOperation.Match(o))
{
return true;
}
}
return false;
});
}
private void SetupQueryEngine()
{
m_QueryEngine = new QueryEngine(false);
}
private Func <T, bool> GenerateInFilterFunction <T>(InFilterNode node, BaseFilterOperation <T> filterOperation, QueryEngine <T> engine, ICollection <QueryError> errors)
{
if (node.leaf || node.children == null || node.children.Count == 0)
{
errors.Add(new QueryError(node.queryStringPosition, "InFilter node cannot be a leaf."));
return(null);
}
var nestedQueryType = GetNestedQueryType(node);
if (nestedQueryType == null)
{
errors.Add(new QueryError(node.queryStringPosition, "Could not deduce nested query type. Did you forget to set the nested query handler?"));
return(null);
}
var transformType = node.filter.queryHandlerTransformer.rightHandSideType;
var inFilterFunc = typeof(WhereEnumerableFactory)
?.GetMethod("GenerateInFilterFunctionWithTypes", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance)
?.MakeGenericMethod(typeof(T), nestedQueryType, transformType)
?.Invoke(this, new object[] { node, filterOperation, engine, errors }) as Func <T, bool>;
if (inFilterFunc == null)
{
errors.Add(new QueryError(node.queryStringPosition, "Could not create filter function with nested query."));
return(null);
}
return(inFilterFunc);
}
public DefaultQueryHandlerFactory(QueryEngine <TData> engine)
{
m_Engine = engine;
}
