/** * This method implements the * operator for "double * double". * * @param left The first value to be multiplied * @param right The second value to be multiplied * @param result The result of a previous call to this method, null if not called yet * @return A SQLDecimal containing the result of the multiplication * @exception StandardException Thrown on error */ public NumberDataValue times(NumberDataValue left, NumberDataValue right, NumberDataValue result) throws StandardException { if (result == null) { result = new SQLDecimal(); } if (left.isNull() || right.isNull()) { result.setToNull(); return result; } result.setBigDecimal(SQLDecimal.getBigDecimal(left).multiply(SQLDecimal.getBigDecimal(right))); return result; }
/** * This method implements the + operator for DECIMAL. * * @param addend1 One of the addends * @param addend2 The other addend * @param result The result of a previous call to this method, null if not called yet * @return A SQLDecimal containing the result of the addition * @exception StandardException Thrown on error */ public NumberDataValue plus( NumberDataValue addend1, NumberDataValue addend2, NumberDataValue result) throws StandardException { if (result == null) { result = new SQLDecimal(); } if (addend1.isNull() || addend2.isNull()) { result.setToNull(); return result; } result.setBigDecimal(SQLDecimal.getBigDecimal(addend1).add(SQLDecimal.getBigDecimal(addend2))); return result; }
/** * Return the SQL scale of this value, number of digits after the decimal point, or zero for a * whole number. This does not match the return from BigDecimal.scale() since in J2SE 5.0 onwards * that can return negative scales. */ public int getDecimalValuePrecision() { if (isNull()) return 0; BigDecimal localValue = getBigDecimal(); return SQLDecimal.getWholeDigits(localValue) + getDecimalValueScale(); }
/** * JDBC 2.0 * * <p>Get the value of a NUMERIC parameter as a java.math.BigDecimal object. * * @param parameterIndex the first parameter is 1, the second is 2, ... * @return the parameter value (full precision); if the value is SQL NULL, the result is null * @exception SQLException if a database-access error occurs. */ public final BigDecimal getBigDecimal(int parameterIndex) throws SQLException { checkStatus(); try { DataValueDescriptor dvd = getParms().getParameterForGet(parameterIndex - 1); if (wasNull = dvd.isNull()) return null; return org.apache.derby.iapi.types.SQLDecimal.getBigDecimal(dvd); } catch (StandardException e) { throw EmbedResultSet.noStateChangeException(e); } }
/** * Set the precision/scale of the to the desired values. Used when CASTing. Ideally we'd recycle * normalize(), but the use is different. * * @param desiredPrecision the desired precision -- IGNORE_PREICISION if it is to be ignored. * @param desiredScale the desired scale * @param errorOnTrunc throw error on truncation (ignored -- always thrown if we truncate the * non-decimal part of the value) * @exception StandardException Thrown on non-zero truncation if errorOnTrunc is true */ public void setWidth(int desiredPrecision, int desiredScale, boolean errorOnTrunc) throws StandardException { if (isNull()) return; if (desiredPrecision != IGNORE_PRECISION && ((desiredPrecision - desiredScale) < SQLDecimal.getWholeDigits(getBigDecimal()))) { throw StandardException.newException( SQLState.LANG_OUTSIDE_RANGE_FOR_DATATYPE, ("DECIMAL/NUMERIC(" + desiredPrecision + "," + desiredScale + ")")); } value = value.setScale(desiredScale, BigDecimal.ROUND_DOWN); rawData = null; }
/** * This method implements the / operator for BigDecimal/BigDecimal * * @param dividend The numerator * @param divisor The denominator * @param result The result of a previous call to this method, null if not called yet * @param scale The result scale, if < 0, calculate the scale according to the actual values' * sizes * @return A SQLDecimal containing the result of the division * @exception StandardException Thrown on error */ public NumberDataValue divide( NumberDataValue dividend, NumberDataValue divisor, NumberDataValue result, int scale) throws StandardException { if (result == null) { result = new SQLDecimal(); } if (dividend.isNull() || divisor.isNull()) { result.setToNull(); return result; } BigDecimal divisorBigDecimal = SQLDecimal.getBigDecimal(divisor); if (divisorBigDecimal.compareTo(ZERO) == 0) { throw StandardException.newException(SQLState.LANG_DIVIDE_BY_ZERO); } BigDecimal dividendBigDecimal = SQLDecimal.getBigDecimal(dividend); /* ** Set the result scale to be either the passed in scale, whcih was ** calculated at bind time to be max(ls+rp-rs+1, 4), where ls,rp,rs ** are static data types' sizes, which are predictable and stable ** (for the whole result set column, eg.); otherwise dynamically ** calculates the scale according to actual values. Beetle 3901 */ result.setBigDecimal( dividendBigDecimal.divide( divisorBigDecimal, scale > -1 ? scale : Math.max( (dividendBigDecimal.scale() + SQLDecimal.getWholeDigits(divisorBigDecimal) + 1), NumberDataValue.MIN_DECIMAL_DIVIDE_SCALE), BigDecimal.ROUND_DOWN)); return result; }
/** @exception StandardException Thrown on error */ protected int typeCompare(DataValueDescriptor arg) throws StandardException { BigDecimal otherValue = SQLDecimal.getBigDecimal(arg); return getBigDecimal().compareTo(otherValue); }
protected void setFrom(DataValueDescriptor theValue) throws StandardException { setCoreValue(SQLDecimal.getBigDecimal(theValue)); }