internal static string ToSerializedValue(this FilterOperatorType value)
{
switch (value)
{
case FilterOperatorType.Equals:
return("Equals");
case FilterOperatorType.IsNull:
return("IsNull");
case FilterOperatorType.GreaterThan:
return("GreaterThan");
case FilterOperatorType.LessThan:
return("LessThan");
case FilterOperatorType.GreaterThanOrEqual:
return("GreaterThanOrEqual");
case FilterOperatorType.LessThanOrEqual:
return("LessThanOrEqual");
case FilterOperatorType.Like:
return("Like");
case FilterOperatorType.Not:
return("Not");
case FilterOperatorType.Between:
return("Between");
case FilterOperatorType.InList:
return("InList");
case FilterOperatorType.And:
return("And");
case FilterOperatorType.Or:
return("Or");
case FilterOperatorType.Cast:
return("Cast");
case FilterOperatorType.InView:
return("InView");
case FilterOperatorType.OfType:
return("OfType");
case FilterOperatorType.RelatedTo:
return("RelatedTo");
case FilterOperatorType.BitwiseAnd:
return("BitwiseAnd");
case FilterOperatorType.BitwiseOr:
return("BitwiseOr");
}
return(null);
}
internal QueryFilterOperator(string token, FilterOperatorType type, IQueryEngineImplementation engine)
{
this.token = token;
this.type = type;
handlers = new Dictionary <Type, Dictionary <Type, IFilterHandlerDelegate> >();
m_EngineImplementation = engine;
}
public FilterOperator(FilterOperatorType FilterOperatorType, String Name, String Value, Shape Shape)
{
this._FilterOperatorType = FilterOperatorType;
this._Name = Name;
this._Value = Value;
this._Shape = Shape;
}
public FilterOperator(FilterOperatorType FilterOperatorType, String Name, String Value, String MinDistance, String MaxDistance)
{
this._FilterOperatorType = FilterOperatorType;
this._Name = Name;
this._Value = Value;
this._MinDistance = MinDistance;
this._MaxDistance = MaxDistance;
}
/// <summary>
/// Является ли тип оператора фильтра сравнением двух заданных полей
/// </summary>
/// <param name="filterOperatorType"></param>
public static bool IsFieldsComparison(this FilterOperatorType filterOperatorType)
{
return(filterOperatorType == FilterOperatorType.EqualsField ||
filterOperatorType == FilterOperatorType.NotEqualsField ||
filterOperatorType == FilterOperatorType.GreaterField ||
filterOperatorType == FilterOperatorType.LessField ||
filterOperatorType == FilterOperatorType.GreaterOrEqualsField ||
filterOperatorType == FilterOperatorType.LessOrEqualsField);
}
/// <summary>Create from XML.</summary>
public override void ReadXml(XmlReader reader)
{
// get the data source table and field
string[] ds = reader.GetAttribute("field").Split(new char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
// set the operand
this._operand = reader.GetAttribute("operand");
// set the operator
string op = reader.GetAttribute("operator");
FilterOperatorType type = (FilterOperatorType)Enum.Parse(typeof(FilterOperatorType), op);
this._op = FilterOperator.GetOperator(type);
// create a new attribute & parent element entity
QueryEngine.Attribute attr = new QueryEngine.Attribute(ds[1], ds[1]);
QueryEngine.Entity parent = new QueryEngine.Entity(ds[0], ds[0]);
attr.Parent = parent;
this._attr = attr;
}
/// <summary>
/// Convert to stack type
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static UaFilterOperator ToStackType(this FilterOperatorType type)
{
switch (type)
{
case FilterOperatorType.Equals:
return(UaFilterOperator.Equals);
case FilterOperatorType.IsNull:
return(UaFilterOperator.IsNull);
case FilterOperatorType.GreaterThan:
return(UaFilterOperator.GreaterThan);
case FilterOperatorType.LessThan:
return(UaFilterOperator.LessThan);
case FilterOperatorType.GreaterThanOrEqual:
return(UaFilterOperator.GreaterThanOrEqual);
case FilterOperatorType.LessThanOrEqual:
return(UaFilterOperator.LessThanOrEqual);
case FilterOperatorType.Like:
return(UaFilterOperator.Like);
case FilterOperatorType.Not:
return(UaFilterOperator.Not);
case FilterOperatorType.Between:
return(UaFilterOperator.Between);
case FilterOperatorType.InList:
return(UaFilterOperator.InList);
case FilterOperatorType.And:
return(UaFilterOperator.And);
case FilterOperatorType.Or:
return(UaFilterOperator.Or);
case FilterOperatorType.Cast:
return(UaFilterOperator.Cast);
case FilterOperatorType.InView:
return(UaFilterOperator.InView);
case FilterOperatorType.OfType:
return(UaFilterOperator.OfType);
case FilterOperatorType.RelatedTo:
return(UaFilterOperator.RelatedTo);
case FilterOperatorType.BitwiseAnd:
return(UaFilterOperator.BitwiseAnd);
case FilterOperatorType.BitwiseOr:
return(UaFilterOperator.BitwiseOr);
default:
throw new NotSupportedException($"{type} not supported");
}
}
/// <summary>Constructor</summary>
private FilterOperator(FilterOperatorType type, string displayText)
{
this._value = type;
this._text = displayText;
}
/// <summary>Constructor</summary>
private FilterOperator(FilterOperatorType type)
{
this._value = type;
}
/// <summary>Gets the instance operator by type.</summary>
public static FilterOperator GetOperator(FilterOperatorType type)
{
return(FilterOperator._opList[type]);
}
/// <summary>Constructor</summary>
public FilterExpression(Attribute a, FilterOperatorType type, string rhs) : this(a, FilterOperator.GetOperator(type), rhs)
{
}
public static Expression ConcatExpressionsWithOperator(Expression left, Expression right, FilterOperatorType expressionOperator)
{
switch (expressionOperator)
{
case FilterOperatorType.Equal:
return(Expression.Equal(left, right));
case FilterOperatorType.NotEqual:
return(Expression.NotEqual(left, right));
case FilterOperatorType.LessThan:
return(Expression.LessThan(left, right));
case FilterOperatorType.GreaterThan:
return(Expression.GreaterThan(left, right));
case FilterOperatorType.LessThanOrEqual:
return(Expression.LessThanOrEqual(left, right));
case FilterOperatorType.GreaterThanOrEqual:
return(Expression.GreaterThanOrEqual(left, right));
case FilterOperatorType.In:
{
MethodInfo method = right.Type.GetMethod("Contains", new[] { typeof(int) });
return(Expression.Call(right, method, left));
}
case FilterOperatorType.Contains:
{
MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
return(Expression.Call(left, method, right));
}
case FilterOperatorType.StartsWith:
{
MethodInfo method = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
return(Expression.Call(left, method, right));
}
case FilterOperatorType.EndsWith:
{
MethodInfo method = typeof(string).GetMethod("EndsWith", new[] { typeof(string) });
return(Expression.Call(left, method, right));
}
default:
return(Expression.Equal(left, right));
}
}
public void SetOperatorType(FilterOperatorType FilterOperatorType)
{
this._FilterOperatorType = FilterOperatorType;
}
