/**
* Implement the cast expression.
*
* <p>TODO: check for overflow
*
* @return the rhs expression casted as the lhs type
*/
public Expression implement() {
// Check for invalid null assignment. Code generated afterwards
// can assume null will never be assigned to a not null value.
checkNotNull();
// Check for an explicit rhs null value. Code generated
// afterwards need never check for an explicit null.
if (rhsType.getSqlTypeName() == SqlTypeName.NULL) {
if (lhsType.isNullable()) {
return castFromNull();
} else {
// NOTE jvs 27-Jan-2005: this code will never actually
// be executed do to previous checkNotNull test, but
// it still has to compile!
return rhsAsValue();
}
}
// Case when left hand side is a nullable primitive
if (translator.isNullablePrimitive(lhsType)) {
if (SqlTypeUtil.isJavaPrimitive(rhsType)
&& (!rhsType.isNullable() || translator.isNullablePrimitive(rhsType))) {
return castPrimitiveToNullablePrimitive();
}
return castToAssignableValue();
}
// Case when left hand side is a not nullable primitive
if (SqlTypeUtil.isJavaPrimitive(lhsType)) {
return castToNotNullPrimitive();
}
// Case when left hand side is a structure
if (lhsType.isStruct()) {
assert (rhsType.isStruct());
// TODO jvs 27-May-2004: relax this assert and deal with
// conversions, null checks, etc.
assert (lhsType.equals(rhsType));
return getDirectAssignment();
}
// Default is to treat non-primitives as AssignableValue
return castToAssignableValue();
}
/**
* 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();
}
