static Cond Compare(Expr expr1, Expr expr2, CompCond op)
{
Cond oper = new Cond();
oper.Term = WhereTerm.CreateCompare(expr1.Expression, expr2.Expression, op);
return(oper);
}
/// <summary>
/// Renders a comaprison operator
/// </summary>
/// <param name="builder"></param>
/// <param name="op"></param>
protected override void Operator(StringBuilder builder, CompCond op)
{
if (op == CompCond.Equal)
{
builder.Append("=");
}
else if (op == CompCond.NotEqual)
{
builder.Append("<>");
}
else if (op == CompCond.Greater)
{
builder.Append(">");
}
else if (op == CompCond.Less)
{
builder.Append("<");
}
else if (op == CompCond.LessOrEqual)
{
builder.Append("<=");
}
else if (op == CompCond.GreaterOrEqual)
{
builder.Append(">=");
}
else if (op == CompCond.Like)
{
builder.Append("ilike");
}
else if (op == CompCond.NotLike)
{
builder.Append("not ilike");
}
else
{
throw new InvalidQueryException("Unkown operator: " + op.ToString());
}
}
/// <summary>
/// Creates a comparison WhereTerm.
/// </summary>
/// <param name="expr1">Expression on the left side of the operator</param>
/// <param name="expr2">Expression on the right side of the operator</param>
/// <param name="op">Conditional operator to be applied on the expressions</param>
/// <returns>A new conditional WhereTerm</returns>
/// <remarks>
/// A comparison term compares two expression on the basis of their values. Expressions can be of any type but their results must be of comparible types.
/// For instance, you can not compare a database field of type 'date' and a static value of type 'int'.
/// </remarks>
/// <example>
/// <code>
/// ...
/// query.WherePhrase.Terms.Add(WhereTerm.CreateCompare(SqlExpression.Field("name", tCustomers), SqlExpression.String("J%"), CompareOperator.Like));
/// </code>
/// </example>
public static WhereTerm CreateCompare(OmExpression expr1, OmExpression expr2, CompCond op)
{
WhereTerm term = new WhereTerm();
term.Expr1 = expr1;
term.Expr2 = expr2;
term.Op = op;
term.Type = WhereTermType.Compare;
return(term);
}
