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;
}
// 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);
}
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.
/// </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>
/// 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 "";
}
