public static <D> SimpleExpression<D> create(Class<D> type, Operator<? super D> op, Expression<?>... args) { return new SimpleOperation<D>(type, op, args); }
/** * Create a new Operation expression * * @param type * @param operator * @param args * @return */ public static <T> SimpleExpression<T> operation(Class<T> type, Operator<? super T> operator, Expression<?>... args) { return SimpleOperation.create(type, operator, args); }
SimpleOperation op = new SimpleOperation(); op.add(); // Valid op.add(2, "two"); // Also valid
@Override protected SimpleExpression<A> createResult(Class<A> type, Expression<A> last) { return SimpleOperation.create(type, Ops.CASE, last); }
Operation op = new SimpleOperation(); op.add(); // Valid op.add(2, "two"); // Invalid
@Override protected Expression<T> createResult(Class<T> type, Expression<T> last) { return SimpleOperation.create(type, Ops.CASE_EQ, base, last); } }.when(other).then(then);
new SimpleOperation("read-resource", true, "subsystem", "undertow", "server", "default-server")
/** * Combine the given expressions into a list expression * * @param clazz * @param exprs * @return */ public static <T> SimpleExpression<T> list(Class<T> clazz, SimpleExpression<?>... exprs) { SimpleExpression<T> rv = (SimpleExpression<T>)exprs[0]; for (int i = 1; i < exprs.length; i++) { rv = SimpleOperation.create(clazz, Ops.LIST, rv, exprs[i]); } return rv; }
public static <D> SimpleExpression<D> create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two) { return new SimpleOperation<D>(type, op, ImmutableList.of(one, two)); }
/** * Create an alias for the expression * * @return */ @Override @SuppressWarnings("unchecked") public SimpleExpression<T> as(Path<T> alias) { return SimpleOperation.create((Class<T>)getType(),Ops.ALIAS, mixin, alias); }
public static <D> SimpleExpression<D> create(Class<D> type, Operator<? super D> op, Expression<?> one) { return new SimpleOperation<D>(type, op, ImmutableList.<Expression<?>>of(one)); }
/** * Get a nextval(sequence) expression of the given type * * @param type * @param sequence * @return */ public static <T extends Number> SimpleExpression<T> nextval(Class<T> type, String sequence) { return SimpleOperation.create(type, SQLOps.NEXTVAL, ConstantImpl.create(sequence)); }
public SimpleExpression<?> as(Expression<?> alias) { return SimpleOperation.create(alias.getType(),Ops.ALIAS, this, alias); }
/** * Get a {@code nullif(this, other)} expression * * @param other * @return */ @SuppressWarnings("unchecked") public SimpleExpression<T> nullif(Expression<T> other) { return SimpleOperation.create((Class<T>)this.getType(), Ops.NULLIF, this, other); }
@SuppressWarnings("unchecked") public SimpleExpression<A> as(Expression<A> alias) { return SimpleOperation.create((Class<A>)getType(),Ops.ALIAS, this, alias); }
@SuppressWarnings("unchecked") public static <D> SimpleExpression<D> as(Expression<D> source, Path<D> alias) { if (source == null) { return as((Expression)NullExpression.DEFAULT, alias); } else { return SimpleOperation.create((Class<D>)alias.getType(), Ops.ALIAS, source, alias); } }
public Q otherwise(Expression<A> expr) { if (expr == null) { expr = (Expression)NullExpression.DEFAULT; } cases.add(0, new CaseElement<A>(null, expr)); Expression<A> last = null; for (CaseElement<A> element : cases) { if (last == null) { last = SimpleOperation.create(type, Ops.CASE_ELSE, element.getTarget()); } else { last = SimpleOperation.create(type, Ops.CASE_WHEN, element.getCondition(), element.getTarget(), last); } } return createResult(type, last); }
public SimpleExpression<A> as(String alias) { return SimpleOperation.create((Class<A>)getType(),Ops.ALIAS, this, new PathImpl<A>(getType(), alias)); }