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