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