/**
* Generates code to round an expression according to the Farrago convention. The Farrago
* convention is to round away from zero. Rounding is performed with the following algorithm.
*
* <pre>
* in = rhs;
* if (value < 0) {
* in = -in;
* out = Math.round(in);
* out = -out;
* } else {
* out = Math.round(in);
* }
* </pre>
*
* <p>PRECONDITION: rhsExp must be an unwrapped (not null) Java primitive
*
* <p>TODO: account for overflow in both unary minus and round.
*/
private Expression roundAway() {
// Get the primitive part of right hand side
RelDataType inType = translator.getTypeFactory().createTypeWithNullability(rhsType, false);
// TODO: is there any preference between stack and instance var?
OJClass inClass = getClass(inType);
Variable inTemp = translator.getRelImplementor().newVariable();
translator.addStatement(declareStackVar(inClass, inTemp, rhsExp));
OJClass outClass = getLhsClass();
Variable outTemp = translator.getRelImplementor().newVariable();
translator.addStatement(declareStackVar(outClass, outTemp, null));
boolean isLong =
translator.getFarragoTypeFactory().getClassForPrimitive(lhsType) == long.class;
addStatement(
new IfStatement(
new BinaryExpression(inTemp, BinaryExpression.LESS, Literal.constantZero()),
new StatementList(
assign(inTemp, minus(inClass, inTemp)),
assign(outTemp, round(lhsClass, inTemp, isLong)),
assign(outTemp, minus(outClass, outTemp))),
new StatementList(assign(outTemp, round(lhsClass, inTemp, isLong)))));
return outTemp;
}
/**
* Adds the statement to the statement list if it is not null. Otherwise, adds the statement to
* the translator list.
*
* @param stmt the statement to be added
*/
private void addStatement(Statement stmt) {
if (stmtList == null) {
translator.addStatement(stmt);
} else {
stmtList.add(stmt);
}
}
/**
* Casts the rhs to a non nullable primitive value. Non nullable primitive values only have a
* single value field.
*/
private Expression castToNotNullPrimitive() {
// If the left and the right types are the same, perform a
// trivial cast.
if (lhsType == rhsType) {
return getDirectAssignment();
}
// Retrieve the value of the right side if it is a nullable
// primitive or a Datetime or an Interval type.
// TODO: is Decimal a nullable primitive?
if (translator.isNullablePrimitive(rhsType)
|| SqlTypeUtil.isDatetime(rhsType)
|| SqlTypeUtil.isInterval(rhsType)) {
rhsExp = getValue(rhsType, rhsExp);
}
// Get the name of the numeric class such as Byte, Short, etc.
String numClassName = SqlTypeUtil.getNumericJavaClassName(lhsType);
OJClass lhsClass = getLhsClass();
// When casting from a string (or binary) to a number, trim the
// value and perform the cast by calling a class-specific parsing
// function.
if ((numClassName != null)
&& SqlTypeUtil.inCharOrBinaryFamilies(rhsType)
&& !SqlTypeUtil.isLob(rhsType)) {
// TODO: toString will cause too much garbage collection.
rhsExp = new MethodCall(rhsExp, "toString", new ExpressionList());
rhsExp = new MethodCall(rhsExp, "trim", new ExpressionList());
String methodName = "parse" + numClassName;
if (lhsType.getSqlTypeName() == SqlTypeName.INTEGER) {
methodName = "parseInt";
}
rhsExp =
new MethodCall(
new Literal(Literal.STRING, numClassName), methodName, new ExpressionList(rhsExp));
Variable outTemp = translator.getRelImplementor().newVariable();
translator.addStatement(
new VariableDeclaration(
TypeName.forOJClass(lhsClass), new VariableDeclarator(outTemp.toString(), rhsExp)));
rhsExp = outTemp;
// Note: this check for overflow should only be required
// when the string conversion does not perform a check.
checkOverflow();
} else if ((lhsType.getSqlTypeName() == SqlTypeName.BOOLEAN)
&& SqlTypeUtil.inCharOrBinaryFamilies(rhsType)
&& !SqlTypeUtil.isLob(rhsType)) {
// Casting from string to boolean relies on the runtime type.
// Note: string is trimmed by conversion method.
// TODO: toString will cause too much garbage collection.
Expression str = new MethodCall(rhsExp, "toString", new ExpressionList());
rhsExp =
new MethodCall(
OJClass.forClass(NullablePrimitive.NullableBoolean.class),
"convertString",
new ExpressionList(str));
} else {
// In general, check for overflow
checkOverflow();
}
roundAsNeeded();
rhsExp = new CastExpression(lhsClass, rhsExp);
return getDirectAssignment();
}