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