/** * Returns the expression representing the ones complement. */ public static UnaryExpression onesComplement(Expression expression, Method method) { return makeUnary(ExpressionType.OnesComplement, expression, expression.getType(), method); }
BinaryExpression(ExpressionType nodeType, Type type, Expression expression0, Expression expression1) { super(nodeType, type); assert expression0 != null : "expression0 should not be null"; assert expression1 != null : "expression1 should not be null"; this.expression0 = expression0; this.expression1 = expression1; this.primitive = Primitive.of(expression0.getType()); }
/** * Creates a UnaryExpression that decrements the expression by 1 * and assigns the result back to the expression. */ public static UnaryExpression preDecrementAssign(Expression expression, Method method) { return makeUnary(ExpressionType.PreDecrementAssign, expression, expression.getType(), method); }
public IndexExpression(Expression array, List<Expression> indexExpressions) { super(ExpressionType.ArrayIndex, Types.getComponentType(array.getType())); assert array != null : "array should not be null"; assert indexExpressions != null : "indexExpressions should not be null"; assert !indexExpressions.isEmpty() : "indexExpressions should not be empty"; this.array = array; this.indexExpressions = indexExpressions; }
/** * Creates a UnaryExpression that represents the assignment of * the expression followed by a subsequent increment by 1 of the * original expression. */ public static UnaryExpression postIncrementAssign(Expression expression, Method method) { return makeUnary(ExpressionType.PostIncrementAssign, expression, expression.getType(), method); }
/** * Creates a UnaryExpression that increments the expression by 1 * and assigns the result back to the expression. */ public static UnaryExpression preIncrementAssign(Expression expression, Method method) { return makeUnary(ExpressionType.PreIncrementAssign, expression, expression.getType(), method); }
/** * Creates a UnaryExpression that represents a unary plus * operation. */ public static UnaryExpression unaryPlus(Expression expression, Method method) { return makeUnary(ExpressionType.UnaryPlus, expression, expression.getType(), method); }
/** * Creates a UnaryExpression that represents the assignment of * the expression followed by a subsequent decrement by 1 of the * original expression. */ public static UnaryExpression postDecrementAssign(Expression expression, Method method) { return makeUnary(ExpressionType.PostDecrementAssign, expression, expression.getType(), method); }
public static Expression convert(Expression operand, Type toType) { final Type fromType = operand.getType(); return convert(operand, fromType, toType); }
private Expression maybeBox(Expression expression) { final Primitive primitive = Primitive.of(expression.getType()); if (primitive != null) { expression = Expressions.box(expression, primitive); } return expression; } }
private Expression maybeBox(Expression expression) { final Primitive primitive = Primitive.of(expression.getType()); if (primitive != null) { expression = Expressions.box(expression, primitive); } return expression; } }
/** * Creates a MemberExpression that represents accessing a field * given the name of the field. */ public static MemberExpression field(Expression expression, String fieldName) { PseudoField field = Types.getField(fieldName, expression.getType()); return makeMemberAccess(expression, field); }
@Override protected void implementNotNullReset(AggContext info, AggResetContext reset) { Expression acc = reset.accumulator().get(0); Primitive p = Primitive.of(acc.getType()); boolean isMin = MIN == info.aggregation(); Object inf = p == null ? null : (isMin ? p.max : p.min); reset.currentBlock().add( Expressions.statement( Expressions.assign(acc, Expressions.constant(inf, acc.getType())))); }
@Override protected void implementNotNullReset(AggContext info, AggResetContext reset) { Expression acc = reset.accumulator().get(0); Primitive p = Primitive.of(acc.getType()); boolean isMin = MIN == info.aggregation(); Object inf = p == null ? null : (isMin ? p.max : p.min); reset.currentBlock().add( Expressions.statement( Expressions.assign(acc, Expressions.constant(inf, acc.getType())))); }
public final void implementReset(AggContext info, AggResetContext reset) { if (trackNullsPerRow) { List<Expression> acc = reset.accumulator(); Expression flag = acc.get(acc.size() - 1); BlockBuilder block = reset.currentBlock(); block.add( Expressions.statement( Expressions.assign(flag, RexImpTable.getDefaultValue(flag.getType())))); } implementNotNullReset(info, reset); }
private Expression getExpression(PhysType physType) { final Expression expression = table.getExpression(Queryable.class); final Expression expression2 = toEnumerable(expression); assert Types.isAssignableFrom(Enumerable.class, expression2.getType()); return toRows(physType, expression2); }
private Expression getExpression(PhysType physType) { final Expression expression = table.getExpression(Queryable.class); final Expression expression2 = toEnumerable(expression); assert Types.isAssignableFrom(Enumerable.class, expression2.getType()); return toRows(physType, expression2); }
protected void implementNotNullReset(AggContext info, AggResetContext reset) { BlockBuilder block = reset.currentBlock(); List<Expression> accumulator = reset.accumulator(); for (int i = 0; i < getStateSize(); i++) { Expression exp = accumulator.get(i); block.add( Expressions.statement( Expressions.assign(exp, RexImpTable.getDefaultValue(exp.getType())))); } }
protected void implementNotNullReset(AggContext info, AggResetContext reset) { BlockBuilder block = reset.currentBlock(); List<Expression> accumulator = reset.accumulator(); for (int i = 0; i < getStateSize(); i++) { Expression exp = accumulator.get(i); block.add( Expressions.statement( Expressions.assign(exp, RexImpTable.getDefaultValue(exp.getType())))); } }
public void implementReset(AggContext info, AggResetContext reset) { List<Expression> acc = reset.accumulator(); reset.currentBlock().add( Expressions.statement( Expressions.assign(acc.get(0), Expressions.constant(false)))); reset.currentBlock().add( Expressions.statement( Expressions.assign(acc.get(1), getDefaultValue(acc.get(1).getType())))); }