protected override Expression VisitBinary(BinaryExpression b) { switch (b.NodeType) { case ExpressionType.AndAlso: Visit(b.Left); _combineOperator = CombineOperator.And; break; case ExpressionType.OrElse: Visit(b.Left); _combineOperator = CombineOperator.Or; break; case ExpressionType.NotEqual: case ExpressionType.Equal: case ExpressionType.LessThan: case ExpressionType.LessThanOrEqual: case ExpressionType.GreaterThan: case ExpressionType.GreaterThanOrEqual: UpdateQuery(b.Left, b.Right, b.NodeType); _combineOperator = CombineOperator.And; return(b); default: throw new NotSupportedException($"The binary operator '{b.NodeType}' is not supported"); } Visit(b.Right); _combineOperator = CombineOperator.And; return(b); }
public void Add(IFilter filter, CombineOperator op = CombineOperator.None) { FilterGroupsList.Add(new FilterGroup() { Filter = filter, Operator = op }); }
public DynamicCombiner([NotNull] IObservable <IObservable <IChangeSet <TObject, TKey> > > source, CombineOperator type) { // _source = source ?? throw new ArgumentNullException(nameof(source)); var xxx = _type = type; }
public DynamicCombiner([NotNull] IObservableList <IObservable <IChangeSet <TObject, TKey> > > source, CombineOperator type) { if (source == null) { throw new ArgumentNullException(nameof(source)); } _source = source; _type = type; }
public static FilterUtil Combine(FilterUtil left, CombineOperator op, FilterUtil right) { var filter = TableQuery.CombineFilters( left.Filter, ToTableOperator(op), right.Filter); return(new FilterUtil(filter)); }
public Combiner([NotNull] ICollection <IObservable <IChangeSet <T> > > source, CombineOperator type) { if (source == null) { throw new ArgumentNullException(nameof(source)); } _source = source; _type = type; }
public DynamicCombiner([NotNull] IObservableList <IObservable <IChangeSet <TObject, TKey> > > source, CombineOperator type) { if (source == null) { throw new ArgumentNullException(nameof(source)); } _source = source; _type = type; _updater = new IntermediateUpdater <TObject, TKey>(_resultCache); }
public static string ToTableOperator(CombineOperator op) { switch (op) { case CombineOperator.And: return(TableOperators.And); case CombineOperator.Or: return(TableOperators.Or); default: throw new InvalidOperationException($"Invalid {nameof(CombineOperator)} value {op}"); } }
private CombineOperator GetOperatorbyString(string co) { CombineOperator c = CombineOperator.And; switch (co) { case "Or": c = CombineOperator.Or; break; } return(c); }
internal TranslateResult Translate(Expression expression) { _query = new RecordQuery(); _combineOperator = CombineOperator.And; Visit(expression); return(new TranslateResult { Query = _query, Selector = _selector }); }
public static string ToStringRepresentation(this CombineOperator op) { switch (op) { case CombineOperator.None: return(""); case CombineOperator.And: return(";"); case CombineOperator.Or: return(","); default: throw new ArgumentOutOfRangeException(nameof(op), op, null); } }
public DynamicCombiner([NotNull] IObservableList <IObservable <IChangeSet <T> > > source, CombineOperator type) { _source = source ?? throw new ArgumentNullException(nameof(source)); _type = type; }
protected override Expression VisitMethodCall(MethodCallExpression m) { var declaringType = m.Method.DeclaringType; if (declaringType != typeof(Queryable) && !typeof(IMetric).IsAssignableFrom(declaringType) && !typeof(IDimension).IsAssignableFrom(declaringType)) { throw new NotSupportedException($"The method '{m.Method.Name}' is not supported"); } switch (m.Method.Name) { case "Where": _combineOperator = CombineOperator.And; Visit(m.Arguments[0]); var lambda = (LambdaExpression)StripQuotes(m.Arguments[1]); Visit(lambda.Body); break; case "OrderBy": case "OrderByDescending": case "ThenBy": case "ThenByDescending": Visit(m.Arguments[0]); var direction = m.Method.Name.Contains("Descending") ? ListSortDirection.Descending : ListSortDirection.Ascending; // TODO: replace column name var unaryExpression = m.Arguments[1] as UnaryExpression; var operand = unaryExpression?.Operand; var memberEx = operand?.GetType()?.GetRuntimeProperty("Body")?.GetValue(operand) as MemberExpression; var info = memberEx?.Member as PropertyInfo; var propertyType = info?.PropertyType; if (propertyType == null || (!typeof(IDimension).IsAssignableFrom(propertyType) && !typeof(IMetric).IsAssignableFrom(propertyType))) { throw new NotSupportedException($"The method '{m.Method.Name}' is not supported"); } _query.SortRulesList.Add(new SortRule(propertyType, direction)); break; case "Skip": Visit(m.Arguments[0]); var skip = m.Arguments[1] as ConstantExpression; if (skip != null) { var startIndex = (int)skip.Value + 1; _query.StartIndex = Convert.ToUInt32(startIndex); } break; case "Take": Visit(m.Arguments[0]); var take = m.Arguments[1] as ConstantExpression; if (take != null) { var recordsCount = (int)take.Value; _query.RecordsCount = Convert.ToUInt32(recordsCount); _query.QueryAll = false; } break; case "Contains": var memberExpression = m.Object as MemberExpression; var propertyInfo = memberExpression?.Member as PropertyInfo; var dimensionType = propertyInfo?.PropertyType; if (dimensionType == null || !typeof(IDimension).IsAssignableFrom(dimensionType)) { throw new NotSupportedException($"The method '{m.Method.Name}' is not supported"); } var expression = m.Arguments.First() as ConstantExpression; var value = expression?.Value?.ToString(); if (string.IsNullOrWhiteSpace(value)) { break; } _query.FiltersList.Add(new Filter(dimensionType, Operator.Contains, value), _combineOperator); break; case "Select": var lambdaExpression = (LambdaExpression)StripQuotes(m.Arguments[1]); Visit(m.Arguments[0]); _selector = lambdaExpression; break; default: throw new NotSupportedException($"The method '{m.Method.Name}' is not supported"); } return(m); }
public static Constraint Combine <T>(IEnumerable <T> items, Func <T, Constraint> constraintPerItem, CombineOperator op) { Constraint result = null; foreach (var item in items) { if (result == null) { result = constraintPerItem(item); } else { if (op is CombineOperator.And) { result &= constraintPerItem(item); } else { result |= constraintPerItem(item); } } } return(result); }
/// <summary> /// Combines a collection of predicates using the supplied operator and uses parameters from the first expression /// </summary> /// <typeparam name="T"></typeparam> /// <param name="predicates"></param> /// <param name="combineOperator"></param> /// <returns></returns> public static Expression <Func <T, bool> > Combine <T>(this IEnumerable <Expression <Func <T, bool> > > predicates, CombineOperator combineOperator) { if (predicates == null || !predicates.Any()) { return(null); } Func <Expression, Expression, BinaryExpression> operatorFunc; switch (combineOperator) { case CombineOperator.And: operatorFunc = Expression.AndAlso; break; case CombineOperator.Or: operatorFunc = Expression.OrElse; break; default: throw new ArgumentOutOfRangeException(nameof(combineOperator)); } return(predicates.Aggregate((Expression <Func <T, bool> >)null, (result, next) => result.Combine(next, operatorFunc))); }
public Combiner(CombineOperator type, Action <IChangeSet <TObject, TKey> > updatedCallback) { _type = type; _updatedCallback = updatedCallback; }
public static string Combine(string left, CombineOperator op, string right) => TableQuery.CombineFilters(left, ToTableOperator(op), right);