com.ibm.as400.access.SQLDouble Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400 Show documentation
Show all versions of jt400 Show documentation
The Open Source version of the IBM Toolbox for Java
The newest version!
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: SQLDouble.java
//
// The source code contained herein is licensed under the IBM Public License
// Version 1.0, which has been approved by the Open Source Initiative.
// Copyright (C) 1997-2006 International Business Machines Corporation and
// others. All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////
package com.ibm.as400.access;
import java.io.InputStream;
import java.math.BigDecimal;
import java.sql.Blob;
import java.sql.Date;
/* ifdef JDBC40 */
import java.sql.NClob;
import java.sql.RowId;
/* endif */
import java.sql.SQLException;
/* ifdef JDBC40 */
import java.sql.SQLXML;
/* endif */
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
final class SQLDouble
extends SQLDataBase
{
static final String copyright = "Copyright (C) 1997-2003 International Business Machines Corporation and others.";
// Private data.
private double value_;
SQLDouble(SQLConversionSettings settings)
{
super(settings);
truncated_ = 0; outOfBounds_ = false;
value_ = 0.0d;
}
public Object clone()
{
return new SQLDouble(settings_);
}
//---------------------------------------------------------//
// //
// CONVERSION TO AND FROM RAW BYTES //
// //
//---------------------------------------------------------//
public void convertFromRawBytes(byte[] rawBytes, int offset, ConvTable ccsidConverter, boolean ignoreConversionErrors) //@P0C
throws SQLException
{
value_ = BinaryConverter.byteArrayToDouble(rawBytes, offset); // @D0C
}
public void convertToRawBytes(byte[] rawBytes, int offset, ConvTable ccsidConverter) //@P0C
throws SQLException
{
BinaryConverter.doubleToByteArray(value_, rawBytes, offset); // @D0C
}
//---------------------------------------------------------//
// //
// SET METHODS //
// //
//---------------------------------------------------------//
public void set(Object object, Calendar calendar, int scale)
throws SQLException
{
truncated_ = 0; outOfBounds_ = false;
if(object instanceof String)
{
try
{
if (settings_.getDecimalSeparator().equals(",")){
object = ((String) object).replace(',','.');
}
value_ = Double.valueOf((String) object).doubleValue();
if (value_ == Double.POSITIVE_INFINITY) {
// Check to see if overflow
if (!((String)object).toLowerCase().trim().equals("infinity")) {
truncated_ = 1; outOfBounds_ = true;
value_ = Double.MAX_VALUE;
}
} else if (value_ == Double.NEGATIVE_INFINITY) {
// Check to see if underflow
if (((String)object).toLowerCase().trim().indexOf("infinity")< 0) {
truncated_ = 1; outOfBounds_ = true;
value_ = -Double.MAX_VALUE;
}
}
// You can't test for data truncation of a number by testing
// the lengths of two string versions of it.
// Example string that should work but will fail:
// "4.749000000000E+00"
//@E2D int objectLength = ((String) object).length();
//@E2D int valueLength = Double.toString(value_).length();
//@E2D if(valueLength < objectLength)
//@E2D truncated_ = objectLength - valueLength;
}
catch(NumberFormatException e)
{
JDError.throwSQLException(this, JDError.EXC_DATA_TYPE_MISMATCH);
}
}
// @ D9d
// else if(object instanceof BigDecimal) {
// value_ = ((BigDecimal) object).doubleValue();
// int objectLength = SQLDataFactory.getPrecision((BigDecimal) object);
// int valueLength = SQLDataFactory.getPrecision(new BigDecimal(value_));
// if(valueLength < objectLength)
// truncated_ = objectLength - valueLength;
// }
else if(object instanceof Number)
{
Number number = (Number) object;
value_ = number.doubleValue();
if (value_ == Double.POSITIVE_INFINITY) {
String stringValue = number.toString().toLowerCase();
if (stringValue.indexOf("inf") == 0) {
// It really is infinity. Accept it.
} else {
truncated_ = 1; outOfBounds_ = true;
value_ = Double.MAX_VALUE;
}
} else if (value_ == Double.NEGATIVE_INFINITY) {
String stringValue = number.toString().toLowerCase();
if (stringValue.indexOf("inf") > 0) {
// It really is infinity. Accept it.
} else {
truncated_ = 1; outOfBounds_ = true;
value_ = - Double.MAX_VALUE;
}
}
}
else if(object instanceof Boolean)
value_ = (((Boolean) object).booleanValue() == true) ? 1d : 0d;
else {
if (JDTrace.isTraceOn()) {
if (object == null) {
JDTrace.logInformation(this, "Unable to assign null object");
} else {
JDTrace.logInformation(this, "Unable to assign object("+object+") of class("+object.getClass().toString()+")");
}
}
JDError.throwSQLException(this, JDError.EXC_DATA_TYPE_MISMATCH);
}
}
//---------------------------------------------------------//
// //
// DESCRIPTION OF SQL TYPE //
// //
//---------------------------------------------------------//
public int getSQLType()
{
return SQLData.DOUBLE;
}
public String getCreateParameters()
{
return null;
}
public int getDisplaySize()
{
return 22;
}
//@F1A JDBC 3.0
public String getJavaClassName()
{
return "java.lang.Double";
}
public String getLiteralPrefix()
{
return null;
}
public String getLiteralSuffix()
{
return null;
}
public String getLocalName()
{
// Use "FLOAT" not "DOUBLE". See ODBC SQLGetTypeInfo().
return "FLOAT";
}
public int getMaximumPrecision()
{
return 53;
}
public int getMaximumScale()
{
return 0;
}
public int getMinimumScale()
{
return 0;
}
public int getNativeType()
{
return 480;
}
public int getPrecision()
{
return 53;
}
public int getRadix()
{
return 2; //@K1C Changed from 10
}
public int getScale()
{
return 0;
}
public int getType()
{
return java.sql.Types.DOUBLE;
}
public String getTypeName()
{
return "DOUBLE";
}
public boolean isSigned()
{
return true;
}
public boolean isText()
{
return false;
}
public int getActualSize()
{
return SQLDataFactory.getPrecision(Double.toString(value_));
}
public int getTruncated()
{
return truncated_;
}
public boolean getOutOfBounds() {
return outOfBounds_;
}
//---------------------------------------------------------//
// //
// CONVERSIONS TO JAVA TYPES //
// //
//---------------------------------------------------------//
public BigDecimal getBigDecimal(int scale)
throws SQLException
{
// Convert the value to a String before creating the
// BigDecimal. This will create the exact BigDecimal
// that we want. If you pass the value directly to
// BigDecimal, then the value is not exact, and the
// scale becomes bigger than expected.
// @A0A
// Modified the code to deal with numbers in scientific
// notations. The numbers that are in scientific notation
// are parsed to a base (the part before 'E') and an
// exponent (the part after 'E'). The base is then used
// to construct the BigDecimal object and then the exponent
// is used to shift the decimal point to its rightful place.
// BigDecimal bigDecimal = new BigDecimal(Double.toString(value_)) // @A0D
truncated_ = 0; outOfBounds_ = false;
BigDecimal bigDecimal = null; // @A0A
String numString = Double.toString(value_); // @A0A
int eIndex = numString.indexOf("E"); // @A0A
if(eIndex == -1)
{ // @A0A
bigDecimal = new BigDecimal(numString); // @A0A
} // @A0A
else
{ // @A0A
String base = numString.substring(0, eIndex); // @A0A
int exponent = Integer.parseInt(numString.substring(eIndex+1)); // @A0A
bigDecimal = new BigDecimal(base); // @A0A
bigDecimal = bigDecimal.movePointRight(exponent); // @A0A
} // @A0A
if(scale >= 0)
{
if(scale >= bigDecimal.scale())
{
truncated_ = 0; outOfBounds_ = false;
return bigDecimal.setScale(scale);
}
else
{
truncated_ = bigDecimal.scale() - scale;
outOfBounds_=false;
return bigDecimal.setScale(scale, BigDecimal.ROUND_HALF_UP);
}
}
else
return bigDecimal;
}
public InputStream getBinaryStream()
throws SQLException
{
JDError.throwSQLException(this, JDError.EXC_DATA_TYPE_MISMATCH);
return null;
}
public Blob getBlob()
throws SQLException
{
JDError.throwSQLException(this, JDError.EXC_DATA_TYPE_MISMATCH);
return null;
}
public boolean getBoolean()
throws SQLException
{
truncated_ = 0; outOfBounds_ = false;
return(value_ != 0.0d);
}
public byte getByte()
throws SQLException
{
truncated_ = 0; outOfBounds_ = false;
if(value_ > Byte.MAX_VALUE || value_ < Byte.MIN_VALUE)
{
if(value_ > Short.MAX_VALUE || value_ < Short.MIN_VALUE)
{
if(value_ > Integer.MAX_VALUE || value_ < Integer.MIN_VALUE)
{
truncated_ = 7; outOfBounds_=true;
}
else
{
truncated_ = 3; outOfBounds_=true;
}
}
else
{
truncated_ = 1; outOfBounds_=true;
}
}
return(byte) value_;
}
public byte[] getBytes()
throws SQLException
{
JDError.throwSQLException(this, JDError.EXC_DATA_TYPE_MISMATCH);
return null;
}
public Date getDate(Calendar calendar)
throws SQLException
{
JDError.throwSQLException(this, JDError.EXC_DATA_TYPE_MISMATCH);
return null;
}
public double getDouble()
throws SQLException
{
truncated_ = 0; outOfBounds_ = false;
return(double) value_;
}
public float getFloat()
throws SQLException
{
truncated_ = 0; outOfBounds_ = false;
if(Double.isInfinite(value_)) { //@tr3a
truncated_ = 0; outOfBounds_ = false; //@tr3a
} else if(value_ > Float.MAX_VALUE || value_ < -Float.MAX_VALUE) //@trunc min_val is a posative number. //Float.MIN_VALUE) //@tr3c
{
truncated_ = 4; outOfBounds_=true;
}
return(float) value_;
}
public int getInt()
throws SQLException
{
truncated_ = 0; outOfBounds_ = false;
if(value_ > Integer.MAX_VALUE || value_ < Integer.MIN_VALUE)
{
truncated_ = 4; outOfBounds_=true;
}
return(int) value_;
}
public long getLong()
throws SQLException
{
truncated_ = 0; outOfBounds_ = false;
if(value_ > Long.MAX_VALUE || value_ < Long.MIN_VALUE)
{
truncated_ = 1; // this is not necessarily correct, but we know there is truncation
outOfBounds_=true;
}
return(long) value_;
}
public Object getObject()
throws SQLException
{
truncated_ = 0; outOfBounds_ = false;
return Double.valueOf(value_);
}
public short getShort()
throws SQLException
{
truncated_ = 0; outOfBounds_ = false;
if(value_ > Short.MAX_VALUE || value_ < Short.MIN_VALUE)
{
if(value_ > Integer.MAX_VALUE || value_ < Integer.MIN_VALUE)
{
truncated_ = 6;
outOfBounds_=true;
}
else
{
truncated_ = 2; outOfBounds_=true;
}
}
return(short) value_;
}
public String getString()
throws SQLException
{
truncated_ = 0; outOfBounds_ = false;
String stringRep = Double.toString(value_);
int decimal = stringRep.indexOf('.');
if(decimal == -1)
return stringRep;
else
return stringRep.substring(0, decimal)
+ settings_.getDecimalSeparator()
+ stringRep.substring(decimal+1);
}
public Time getTime(Calendar calendar)
throws SQLException
{
JDError.throwSQLException(this, JDError.EXC_DATA_TYPE_MISMATCH);
return null;
}
public Timestamp getTimestamp(Calendar calendar)
throws SQLException
{
JDError.throwSQLException(this, JDError.EXC_DATA_TYPE_MISMATCH);
return null;
}
/* ifdef JDBC40 */
//@pda jdbc40
public RowId getRowId() throws SQLException
{
JDError.throwSQLException(this, JDError.EXC_DATA_TYPE_MISMATCH);
return null;
}
//@pda jdbc40
public SQLXML getSQLXML() throws SQLException
{
JDError.throwSQLException(this, JDError.EXC_DATA_TYPE_MISMATCH);
return null;
}
/* endif */
public void saveValue() {
savedValue_ = Double.valueOf(value_);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy