public static string OperatorToString(ComparisonOperators comparisonOperator) { switch (comparisonOperator) { case ComparisonOperators.Equal: return("="); case ComparisonOperators.NotEqual: return("!="); case ComparisonOperators.Less: return("<"); case ComparisonOperators.LessOrEqual: return("<="); case ComparisonOperators.Greater: return(">"); case ComparisonOperators.GreaterOrEqual: return(">="); case ComparisonOperators.StartsWith: return("[начинается с]"); } return(String.Empty); }
private bool VectorCheck( Vector4 LHS, ComparisonOperators op, object expectedValue ) { var RHS = (Vector4)expectedValue: if( RHS.x != float.NegativeInfinity ) { if( !Check( LHS.x, op, RHS.x ) ) return false: } if( RHS.y != float.NegativeInfinity ) { if( !Check( LHS.y, op, RHS.y ) ) return false: } if( RHS.z != float.NegativeInfinity ) { if( !Check( LHS.z, op, RHS.z ) ) return false: } if( RHS.w != float.NegativeInfinity ) { if( !Check( LHS.w, op, RHS.w ) ) return false: } return true: }
/// <summary> /// Get LINQ comparison operator representation /// </summary> /// <param name="operators">Comparison operator</param> /// <param name="isEnumValue">Indicate when comparison value is enum</param> /// <param name="isNullValue">Indicate when comparison value is null</param> /// <returns>LINQ comparison operator representation</returns> protected static string ComparisonFilterOperatorToLinq(ComparisonOperators operators, bool isEnumValue, bool isNullValue = false) { switch (operators) { case ComparisonOperators.Equal: return(isEnumValue ? " = " : " == "); case ComparisonOperators.NotEqual: return(" != "); case ComparisonOperators.Less: return(" < "); case ComparisonOperators.LessOrEqual: return(" <= "); case ComparisonOperators.Greater: return(" > "); case ComparisonOperators.GreaterOrEqual: return(" >= "); case ComparisonOperators.StartsWith: return(isNullValue ? (isEnumValue ? " = " : " == ") : ".StartsWith"); } return(String.Empty); }
/// <summary> Return the text that should be inserted for a logical <c>AND</c> operation</summary> public override string GetOperator(ComparisonOperators op) { switch (op) { case ComparisonOperators.EQ: return(" = "); case ComparisonOperators.NE: return(" != "); case ComparisonOperators.GT: return(" > "); case ComparisonOperators.LT: return(" < "); case ComparisonOperators.GE: return(" >= "); case ComparisonOperators.LE: return(" <= "); } return(""); }
public static string getcopstr(ComparisonOperators cop) { switch (cop) { case ComparisonOperators.Equal: return cops.Equal; case ComparisonOperators.NotEqual: return cops.NotEqual; case ComparisonOperators.Greater: return cops.Greater; case ComparisonOperators.Less: return cops.Less; case ComparisonOperators.NotLessThan: return cops.NotLessThan; case ComparisonOperators.NotGreaterThan: return cops.NotGreaterThan; case ComparisonOperators.Like: return cops.Like; case ComparisonOperators.NotLike: return cops.NotLike; case ComparisonOperators.In: return cops.In; case ComparisonOperators.NotIn: return cops.NotIn; case ComparisonOperators.BetweenAnd: return cops.BetweenAnd; default: return cops.Equal; } }
public Criteria(string property, ComparisonOperators comparisonOperators, object value) { this.Property = property; this.ComparisonOperator = comparisonOperators; this.Value = value; this.CriteriaType = CriteriaTypes.Comparison; }
private string GetComparisonOperator(ComparisonOperators Operator) { switch (Operator) { case ComparisonOperators.Equal: return("eq"); case ComparisonOperators.NotEqual: return("ne"); case ComparisonOperators.GreaterThan: return("gt"); case ComparisonOperators.GreatThanOrEqual: return("ge"); case ComparisonOperators.LessThan: return("lt"); case ComparisonOperators.LessThanOrEqual: return("le"); default: return(string.Empty); } }
public FilterCriteria(string Field, ComparisonOperators ComparisonOperator, LogicalOperators LogicalOperator, object Value) { this.Field = Field; this.ComparisonOperator = ComparisonOperator; this.LogicalOperator = LogicalOperator; this.Value = Value; }
protected bool Check( object LHS, ComparisonOperators op, object RHS ) { if( !( LHS is IComparable ) || !( RHS is IComparable ) ) throw new Exception( "Check using non basic type" ): switch( op ) { case ComparisonOperators.EqualTo: return ( (IComparable)LHS ).CompareTo( RHS ) == 0: case ComparisonOperators.NotEqualTo: return ( (IComparable)LHS ).CompareTo( RHS ) != 0: case ComparisonOperators.EqualsOrGreaterThan: return ( (IComparable)LHS ).CompareTo( RHS ) >= 0: case ComparisonOperators.EqualsOrLessThan: return ( (IComparable)LHS ).CompareTo( RHS ) <= 0: case ComparisonOperators.GreaterThan: return ( (IComparable)LHS ).CompareTo( RHS ) > 0: case ComparisonOperators.LessThan: return ( (IComparable)LHS ).CompareTo( RHS ) < 0: case ComparisonOperators.ContainsFlags: return ( (int)LHS & (int)RHS ) != 0: // Dont trust LHS values, it has been casted to a char and then to an int again, first bit will be the sign case ComparisonOperators.DoesNotContainsFlags: return ( ( (int)LHS & (int)RHS ) == (int)LHS ): // Dont trust LHS values, it has been casted to a char and then to an int again, first bit will be the sign default: break: } return false: }
protected override void search_btn_Click(object sender, System.Windows.RoutedEventArgs e) { List <SearchParams> list = new List <SearchParams>(); foreach (SearchParamsControls spc in stackPanel.Children) { String conditionalOperator = spc.Operator_Combobox.ItemsSource == null ? null : spc.Operator_Combobox.SelectedItem.ToString(); int fieldComboBoxidx = spc.Field_Combobox.SelectedIndex; int operatoor = spc.ComparisonOperators_Combobox.SelectedIndex; String value = spc.ValueField.Text; SearchParams temp = new SearchParams(); temp.FieldID = Columns.ElementAt(fieldComboBoxidx).FieldID; temp.ConditionalOperator = conditionalOperator; temp.OperatorID = ComparisonOperators.ElementAt(operatoor).OperatorID; temp.Value = value; list.Add(temp); } DataTable dt = SearchFrameworkHelper.Search(list); if (dt != null) { dataGrid.ItemsSource = dt.DefaultView; } else { MessageBox.Show("Logical Error"); } }
// Construction with an operator & comparand public ComparisonBinding(string path, ComparisonOperators op, object comparand) : base(path) { RelativeSource = RelativeSource.Self; Comparand = comparand; Operator = op; Converter = new ComparisonConverter(this); }
public Criteria(Type EntityComparison, string property, ComparisonOperators comparisonOperators, object value) { this.ComparisonEntityName = EntityComparison.GetField("TableName").GetRawConstantValue().ToString(); this.Property = property; this.ComparisonOperator = comparisonOperators; this.Value = value; this.CriteriaType = CriteriaTypes.Comparison; }
private static bool Equals(RepresentationAttribute attr, ComparisonOperators op, string value) { if (attr.SchemaAttribute.MultiValued) { var enumAttr = attr as SingularRepresentationAttribute <IEnumerable <string> >; if (enumAttr == null) { return(false); } switch (op) { case ComparisonOperators.co: return(enumAttr.Value.Contains(value)); } return(false); } var attrValue = attr as SingularRepresentationAttribute <string>; if (attrValue == null) { return(false); } switch (op) { case ComparisonOperators.eq: return(attrValue.Value.Equals(value)); case ComparisonOperators.ne: return(!attrValue.Value.Equals(value)); case ComparisonOperators.sw: return(attrValue.Value.StartsWith(value)); case ComparisonOperators.ew: return(attrValue.Value.EndsWith(value)); case ComparisonOperators.pr: return(!string.IsNullOrWhiteSpace(attrValue.Value)); case ComparisonOperators.gt: return(attrValue.Value.CompareTo(value) > 0); case ComparisonOperators.ge: return(attrValue.Value.CompareTo(value) > 0 || attrValue.Value.Equals(value)); case ComparisonOperators.lt: return(attrValue.Value.CompareTo(value) < 0); case ComparisonOperators.le: return(attrValue.Value.CompareTo(value) < 0 || attrValue.Value.Equals(value)); } return(false); }
private void SetSelectedComparisonOperator(ComparisonOperators selectedOperator) { var comparisonNode = SelectedExpression as ComparisonOperatorNode; if (comparisonNode != null) { comparisonNode.Operator = selectedOperator; } }
/// <summary> Constructs a query condition</summary> /// <param name="field">A static constant defined by the <c>Adk</c> /// to identify the field (i.e. element or attribute) to evaluate /// </param> /// <param name="ops">The comparison operator</param> /// <param name="val">The value to evaluate /// </param> public Condition(IElementDef field, ComparisonOperators ops, string val) { fField = field; fOps = ops; fValue = val; fXPath = field.GetSQPPath(Adk.SifVersion); }
/// <summary> /// Internal only. Creates a query condition by evaluating the XPath. /// If possible, the ElementDef representing the field will be evaluated /// </summary> /// <param name="objectDef">The metadata definition of the parent object</param> /// <param name="xPath">The xpath to the field</param> /// <param name="ops">The ComparisonOperator to apply</param> /// <param name="value">The value to compare the field to</param> internal Condition(IElementDef objectDef, String xPath, ComparisonOperators ops, String value) { fOps = ops; fValue = value; fXPath = xPath; IElementDef target = Adk.Dtd.LookupElementDefBySQP(objectDef, xPath); fField = target; }
/// <summary> /// Constructor for all parameters /// </summary> /// <param name="boundProperty">Filterable property description</param> /// <param name="valueTemplate">DataTemplate for generation property value</param> /// <param name="value">Property value</param> /// <param name="filterOperator">Comparision filtration operator</param> public FilterRowContainer(FieldDescription boundProperty, DataTemplate valueTemplate, object value, ComparisonOperators filterOperator) { BoundProperty = boundProperty; ValueTemplate = valueTemplate; _value = value; FilterOperator = filterOperator; _isClearing = false; }
public Condition ToCondition(ComparisonOperators compOp, BinaryOperators binOp) { var cond = new Condition() { PropertyName = this.Name, ComparisonOperator = compOp, Value1 = this.Value, BinaryOperator = binOp }; return(cond); }
private static bool Compare(RepresentationAttribute attr, ComparisonOperators op, string value) { switch (attr.SchemaAttribute.Type) { case Common.Constants.SchemaAttributeTypes.String: return(Equals(attr, op, value)); case Common.Constants.SchemaAttributeTypes.Boolean: var b = false; if (!bool.TryParse(value, out b)) { return(false); } return(Equals(attr, op, b)); case Common.Constants.SchemaAttributeTypes.DateTime: DateTime d = default(DateTime); if (!DateTime.TryParse(value, out d)) { return(false); } return(Equals(attr, op, d)); case Common.Constants.SchemaAttributeTypes.Decimal: decimal dec; if (!decimal.TryParse(value, out dec)) { return(false); } return(Equals(attr, op, dec)); case Common.Constants.SchemaAttributeTypes.Integer: int i; if (!int.TryParse(value, out i)) { return(false); } return(Equals(attr, op, i)); case Common.Constants.SchemaAttributeTypes.Complex: var complexAttr = attr as ComplexRepresentationAttribute; if (complexAttr == null) { return(false); } return(Equals(complexAttr, op, value)); } return(false); }
public Filter(string colName, object Value, ComparisonOperators cop) { if (SqlFactory.GetColType(Value.GetType()) == 1) { Expression = System.String.Format(" {0} {1} '{2}' ", colName, cops.getcopstr(cop), Value); } else { Expression = System.String.Format(" {0} {1} {2} ", colName, cops.getcopstr(cop), Value); } }
private static Expression GetAttributeExpression(IEnumerable <string> parameters) { ComparisonOperators op = (ComparisonOperators)Enum.Parse(typeof(ComparisonOperators), parameters.ElementAt(1)); return(new CompAttributeExpression { Operator = op, Value = op != ComparisonOperators.pr ? parameters.ElementAt(2) : null, Path = GetPath(parameters.First()) }); }
public Filter(string colName,object Value,ComparisonOperators cop) { if (SqlFactory.GetColType(Value.GetType()) == 1) { Expression = System.String.Format(" {0} {1} '{2}' ", colName, cops.getcopstr(cop), Value); } else { Expression = System.String.Format(" {0} {1} {2} ", colName, cops.getcopstr(cop), Value); } }
private bool CheckObject( object LHS, ComparisonOperators comparasonOperator, object RHS ) { switch( comparasonOperator ) { case ComparisonOperators.EqualTo: return ( LHS == null ): case ComparisonOperators.NotEqualTo: return ( LHS != null ): } return true: }
private static bool Equals(RepresentationAttribute attr, ComparisonOperators op, int value) { if (attr.SchemaAttribute.MultiValued) { var enumAttr = attr as SingularRepresentationAttribute <IEnumerable <int> >; if (enumAttr == null) { return(false); } switch (op) { case ComparisonOperators.co: return(enumAttr.Value.Contains(value)); } return(false); } var attrValue = attr as SingularRepresentationAttribute <int>; if (attrValue == null) { return(false); } switch (op) { case ComparisonOperators.eq: return(attrValue.Value.Equals(value)); case ComparisonOperators.ne: return(!attrValue.Value.Equals(value)); case ComparisonOperators.pr: return(true); case ComparisonOperators.gt: return(attrValue.Value.CompareTo(value) > 0); case ComparisonOperators.ge: return(attrValue.Value.CompareTo(value) > 0 || attrValue.Value.Equals(value)); case ComparisonOperators.lt: return(attrValue.Value.CompareTo(value) < 0); case ComparisonOperators.le: return(attrValue.Value.CompareTo(value) < 0 || attrValue.Value.Equals(value)); } return(false); }
public Task Parse(Step step, string stepExpression, GherkinParseResult parseResult, BuildProject buildProject) { if (buildProject.Build.Assembly.IsNullOrEmpty()) { parseResult.AddError("No valid assembly to test", step.Location.Line, step.Location.Column); } else { byte[] assembly = buildProject.Build.Assembly; if (assembly == null) { parseResult.AddError("No calculations available for this test", step.Location.Line, step.Location.Column); } else { string[] matches = Regex.Split(step.Text, stepExpression, RegexOptions.IgnoreCase); string calcName = matches[7]; string comparison = matches[9]; string value = matches[11]; MethodInformation calculation = FindCalculationMethod(assembly, calcName); if (calculation == null) { parseResult.AddError($"Calculation: '{calcName}' was not found to test", step.Location.Line, step.Location.Column); } if (!ComparisonOperators.Values.Contains(comparison.ToLower())) { parseResult.AddError($"'{comparison}' is not a valid comparison", step.Location.Line, step.Location.Column); } if (!Decimal.TryParse(value, out var result)) { parseResult.AddError($"'{value}' is not a valid decimal", step.Location.Line, step.Location.Column); } parseResult.StepActions.Add(new ThenCalculationValue { CalculationName = calcName, Operator = ComparisonOperators.FirstOrDefault(x => x.Value == comparison).Key, Value = value }); } } return(Task.CompletedTask); }
private void PopulateConditions(SIF_Query query, SIF_Condition[] clist, ConditionGroup target) { for (int i = 0; i < clist.Length; i++) { String o = clist[i].SIF_Operator; ComparisonOperators ops = Condition.ParseComparisionOperators(o); String val = clist[i].SIF_Value; String path = clist[i].SIF_Element; target.AddCondition(fObjType, path, ops, val); } }
public static bool TimeComparison(TimeSpan objValue1, TimeSpan objValue2, ComparisonOperators enuOperator) { switch (enuOperator) { case ComparisonOperators.Equal: return objValue1 == objValue2; case ComparisonOperators.NotEqual: return objValue1 != objValue2; case ComparisonOperators.GreaterThan: return objValue1 > objValue2; case ComparisonOperators.GreaterThanOrEqual: return objValue1 >= objValue2; case ComparisonOperators.LessThan: return objValue1 < objValue2; case ComparisonOperators.LessThanOrEqual: return objValue1 <= objValue2; default: return false; } }
/// <summary> /// Add a condition to this query. /// </summary> /// <remarks> /// This method of adding conditions is convenient for adding conditions involving /// root attributes or elements to a query. If you need to add conditions on deeply /// nested elements, use <see cref="AddCondition(string,ComparisonOperators,string)"/> /// </remarks> /// <param name="field">A constant from the package DTD class that identifies an element /// or attribute of the data object (e.g. <c>StudentDTD.STUDENTPERSONAL_REFID</c>)</param> /// <param name="ops">The comparison operator. Comparison operator constants are /// defined by the ComparisionOperators enum</param> /// <param name="value">The data that is used to compare to the element or attribute</param> /// <exception cref="ArgumentException">if the ElementDef does not represent an immediate /// child of the object being queried.</exception> public void AddCondition(IElementDef field, ComparisonOperators ops, String value) { // Do some validation to try to prevent invalid query paths from being created String relativePath = field.GetSQPPath(Adk.SifVersion); IElementDef lookedUp = Adk.Dtd.LookupElementDefBySQP(fObjType, relativePath); if (lookedUp == null) { throw new ArgumentException("Invalid path: " + fObjType.Name + "/" + relativePath + " is unable to be resolved"); } AddCondition(new Condition(fObjType, relativePath, ops, value)); }
/// <summary> /// Filter by value from fast filter row /// </summary> /// <param name="property">Filter property</param> /// <param name="value">Filter field value</param> /// <param name="filterOperator">Filter operator</param> private void FilterByValue(FieldDescription property, object value, ComparisonOperators filterOperator) { if (_filterByValueTokenSource != null) { _filterByValueTokenSource.Cancel(); } _filterByValueTokenSource = new CancellationTokenSource(); Task.Run(() => FilterByValueAsync(_filterByValueTokenSource.Token, property, value, filterOperator), _filterByValueTokenSource.Token); }
/// <summary> /// Initializes a new instance of the <see cref="RelationalOperation" /> class. /// </summary> /// <param name="operator">The operator.</param> /// <param name="leftExpression">The left expression.</param> /// <param name="rightExpression">The right expression.</param> /// <param name="editable">if set to <see langword="true" /> [editable].</param> public RelationalOperation(ComparisonOperators @operator, IExpression?leftExpression, IExpression?rightExpression, bool editable = false) { Parent = null; Comparand = leftExpression; if (Comparand is IExpression l) { l.Parent = this; } Comparanda = rightExpression; if (Comparanda is IExpression r) { r.Parent = this; } Operator = @operator; Editable = editable; }
public static string GetComparisonOperatorCSharp(ComparisonOperators op) { string eOp = string.Empty; switch (op) { case ComparisonOperators.Equal: eOp = "=="; break; case ComparisonOperators.NotEqual: eOp = "!="; break; case ComparisonOperators.LessThan: eOp = "<"; break; case ComparisonOperators.LessOrEqualThan: eOp = "<="; break; case ComparisonOperators.GreaterThan: eOp = ">"; break; case ComparisonOperators.GreaterOrEqualThan: eOp = ">="; break; case ComparisonOperators.IsNull: eOp = "== null"; break; case ComparisonOperators.IsNotNull: eOp = "!= null"; break; case ComparisonOperators.Contains: eOp = "LIKE"; break; default: break; } return(eOp); }
private void Init(object fieldname, object comparison, object expectedvalue) { FieldName = fieldname.ToString(); var names = Enum.GetNames(typeof(ComparisonOperators)); var name = comparison.ToString().ToLower().Replace(" ", ""); for (int i = 0; i < names.Length; i++) { if (names[i].ToLower() == name) { op = (ComparisonOperators)i; break; } } ExpectedValue = expectedvalue; }
public static ComparisonOperators GetComparisonOperator(string op) { ComparisonOperators eOp = ComparisonOperators.Equal; switch (op) { case "=": case "==": eOp = ComparisonOperators.Equal; break; case "!=": case "<>": eOp = ComparisonOperators.NotEqual; break; case "<": eOp = ComparisonOperators.LessThan; break; case "<=": eOp = ComparisonOperators.LessOrEqualThan; break; case ">": eOp = ComparisonOperators.GreaterThan; break; case ">=": eOp = ComparisonOperators.GreaterOrEqualThan; break; case "IS NULL": eOp = ComparisonOperators.IsNull; break; case "LIKE": eOp = ComparisonOperators.Contains; break; default: break; } return(eOp); }
public static bool Compare(object objValue1, object objValue2, ComparisonOperators enuOperator, Type objInnerType) { if (objInnerType == typeof(Double)) { return Comparator.NumericComparison(SqlConvert.ToDouble(objValue1), SqlConvert.ToDouble(objValue2), enuOperator); } else if (objInnerType == typeof(DateTime)) { return Comparator.DateComparison(SqlConvert.ToDateTime(objValue1), SqlConvert.ToDateTime(objValue2), enuOperator); } else if (objInnerType == typeof(TimeSpan)) { return Comparator.TimeComparison((TimeSpan)objValue1, (TimeSpan)objValue2, enuOperator); } else { throw new ArgumentException("Unsupported Type for Comparison"); } }
// Added by Paul Welter (http://www.LoreSoft.com) /// <summary> /// Returns the database provider-specific expression, like /// [TableName].[FieldName] = 'Value', given an entity-alias /// object description, like ClassName.PropertyName, and value /// </summary> /// <param name="entityAlias">The entity alias to use in the expression</param> /// <param name="fieldValue">The value to use in the expression</param> /// <param name="comparison">The comparison operator to use with this expression</param> /// <returns>The database provider-specific expression</returns> public string GetExpression(string entityAlias, object fieldValue, ComparisonOperators comparison) { string fieldName = this.GetFieldName(entityAlias); if (fieldValue == null || fieldValue == DBNull.Value) { switch (comparison) { case ComparisonOperators.IsNotNull: return fieldName + " IS NOT NULL"; default : return fieldName + " IS NULL"; } } else { string value = this.CleanValue(fieldValue); switch (comparison) { case ComparisonOperators.GreaterThan: return fieldName + " > " + value; case ComparisonOperators.GreaterThanEqual: return fieldName + " >= " + value; case ComparisonOperators.IsNotNull: return fieldName + " IS NOT NULL"; case ComparisonOperators.IsNull: return fieldName + " IS NULL"; case ComparisonOperators.LessThan: return fieldName + " < " + value; case ComparisonOperators.LessThanEqual: return fieldName + " <= " + value; case ComparisonOperators.Like: return fieldName + " LIKE " + value; case ComparisonOperators.NotEqual: return fieldName + " <> " + value; default: return fieldName + " = " + value; } } }
/// <summary>Adds a condition to this group</summary> /// <remarks> /// This method of adding conditions is convenient for adding conditions involving /// root attributes or elements to a query. If you need to add conditions on deeply /// nested elements, use <see cref="ConditionGroup.AddCondition(String, ComparisonOperators, String)" /> /// </remarks> public virtual void AddCondition( IElementDef field, ComparisonOperators ops, string val ) { AddCondition( new Condition( field, ops, val ) ); }
/// <summary> /// Internal only. Adds a query condition to this condition group by evaluating the XPath. /// If possible, the IElementDef representing the field will be evaluated /// </summary> /// <param name="objectDef">The metadata definition of the parent object</param> /// <param name="xPath">The xpath to the field</param> /// <param name="ops">The ComparisonOperator to apply</param> /// <param name="value">The value to compare the field to</param> internal void AddCondition( IElementDef objectDef, String xPath, ComparisonOperators ops, String value ) { AddCondition( new Condition( objectDef, xPath, ops, value ) ); }
/// <summary> /// Add a condition to this query using a deeply nested path. Using this /// method of adding query condition allows for specifying deeply nested query /// conditions. However, the xpath specified here is specific to the version /// of SIF /// </summary> /// <remarks>To ensure your code works with all versions of SIF, you should use /// <see cref="Query.AddCondition(IElementDef, ComparisonOperators, String)"/> /// whenever possible.</remarks> /// <param name="xPath">he Simple XPath to use for this query condition. E.g. /// <c>SIF_ExendedElements/SIF_ExtendedElement[@Name='eyecolor']</c></param> /// <param name="ops">Comparison operator value from the /// ComparisonOperators enum</param> /// <param name="value">The data that is used to compare to the element or attribute</param> public void AddCondition(String xPath, ComparisonOperators ops, String value) { AddCondition(new Condition(fObjType, xPath, ops, value)); }
/// <summary> Return the text that should be inserted for a logical <c>AND</c> operation</summary> public override string GetOperator( ComparisonOperators op ) { switch (op) { case ComparisonOperators.EQ: return " = "; case ComparisonOperators.NE: return " != "; case ComparisonOperators.GT: return " > "; case ComparisonOperators.LT: return " < "; case ComparisonOperators.GE: return " >= "; case ComparisonOperators.LE: return " <= "; } return ""; }