/** * @return An expression representing inequality between two attributes * (columns). */ public Expression ne(Property<?> value) { return ExpressionFactory.noMatchExp(getExpression(), value.getExpression()); }
/** * @return Represents a greater than relationship between two attributes * (columns). */ public Expression gt(Property<?> value) { return ExpressionFactory.greaterExp(getExpression(), value.getExpression()); }
/** * @return Represents a less than or equal relationship between two * attributes (columns). */ public Expression lte(Property<?> value) { return ExpressionFactory.lessOrEqualExp(getExpression(), value.getExpression()); }
/** * @return An expression representing equality to FALSE. */ public Expression isFalse() { return ExpressionFactory.matchExp(getExpression(), Boolean.FALSE); }
/** * @return An expression representing equality to a value. */ public Expression eq(E value) { return ExpressionFactory.matchExp(getExpression(), value); }
/** * Creates an expression for a database "LIKE" query with the value converted to a pattern matching the beginning of * a String. * * @param value a String to match against property value. "_" and "%" symbols * are NOT treated as wildcards and are escaped when converted to * a LIKE expression. * @return a newly created expression. */ public Expression startsWith(String value) { return ExpressionFactory.startsWithExp(getExpression(), value); }
/** * Creates an expression for a database "LIKE" query with the value * converted to a pattern matching the tail of a String. * * @param value a String to match against property value. "_" and "%" symbols * are NOT treated as wildcards and are escaped when converted to * a LIKE expression. * @return a newly created expression. */ public Expression endsWith(String value) { return ExpressionFactory.endsWithExp(getExpression(), value); }
/** * @param lower The lower bound. * @param upper The upper bound. * @return An expression checking for objects between a lower and upper * bound inclusive */ public Expression between(E lower, E upper) { return ExpressionFactory.betweenExp(getExpression(), lower, upper); }
/** * @return An expression for finding objects with values not in the given * set. */ public Expression nin(Collection<E> values) { return ExpressionFactory.notInExp(getExpression(), values); }
/** * @return An expression representing null. */ public Expression isNull() { return ExpressionFactory.matchExp(getExpression(), null); }
/** * @return An expression representing inequality to a value. */ public Expression ne(E value) { return ExpressionFactory.noMatchExp(getExpression(), value); }
/** * Same as {@link #endsWith(String)}, only using case-insensitive * comparison. */ public Expression endsWithIgnoreCase(String value) { return ExpressionFactory.endsWithIgnoreCaseExp(getExpression(), value); }
/** * @return Ascending sort orderings on this property. */ public Ordering asc() { return new Ordering(getExpression(), SortOrder.ASCENDING); }
/** * @return A greater than or equal to Expression. */ public Expression gte(E value) { return ExpressionFactory.greaterOrEqualExp(getExpression(), value); }
/** * @see FunctionExpressionFactory#substringExp(Expression, int, int) */ public Property<String> substring(int offset, int length) { return create(FunctionExpressionFactory.substringExp(getExpression(), offset, length), String.class); }
/** * @see FunctionExpressionFactory#lowerExp(Expression) */ public Property<String> lower() { return create(FunctionExpressionFactory.lowerExp(getExpression()), String.class); }
/** * @see FunctionExpressionFactory#sumExp(Expression) */ public Property<E> sum() { return create(FunctionExpressionFactory.sumExp(getExpression()), getType()); }
/** * @see FunctionExpressionFactory#maxExp(Expression) */ public Property<E> max() { return create(FunctionExpressionFactory.maxExp(getExpression()), getType()); }
/** * @see FunctionExpressionFactory#avgExp(Expression) */ public Property<E> avg() { return create(FunctionExpressionFactory.avgExp(getExpression()), getType()); }
/** * @see FunctionExpressionFactory#modExp(Expression, Number) */ public Property<E> mod(Number number) { return create(FunctionExpressionFactory.modExp(getExpression(), number), getType()); }