You are viewing a plain text version of this content. The canonical link for it is here.
Posted to derby-commits@db.apache.org by jb...@apache.org on 2005/05/02 08:26:03 UTC
svn commit: r165585 [9/42] - in
/incubator/derby/code/trunk/java/client/org/apache/derby: client/
client/am/ client/net/ client/resources/ jdbc/
Modified: incubator/derby/code/trunk/java/client/org/apache/derby/client/am/CrossConverters.java
URL: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/am/CrossConverters.java?rev=165585&r1=165584&r2=165585&view=diff
==============================================================================
--- incubator/derby/code/trunk/java/client/org/apache/derby/client/am/CrossConverters.java (original)
+++ incubator/derby/code/trunk/java/client/org/apache/derby/client/am/CrossConverters.java Sun May 1 23:25:59 2005
@@ -36,1587 +36,1585 @@
// java.sql.Types.CLOB;
// java.sql.Types.BLOB;
//
-final class CrossConverters
-{
- private final static java.math.BigDecimal bdMaxByteValue__ =
- java.math.BigDecimal.valueOf (Byte.MAX_VALUE);
- private final static java.math.BigDecimal bdMinByteValue__ =
- java.math.BigDecimal.valueOf (Byte.MIN_VALUE);
- private final static java.math.BigDecimal bdMaxShortValue__ =
- java.math.BigDecimal.valueOf (Short.MAX_VALUE);
- private final static java.math.BigDecimal bdMinShortValue__ =
- java.math.BigDecimal.valueOf (Short.MIN_VALUE);
- private final static java.math.BigDecimal bdMaxIntValue__ =
- java.math.BigDecimal.valueOf (Integer.MAX_VALUE);
- private final static java.math.BigDecimal bdMinIntValue__ =
- java.math.BigDecimal.valueOf (Integer.MIN_VALUE);
- private final static java.math.BigDecimal bdMaxLongValue__ =
- java.math.BigDecimal.valueOf (Long.MAX_VALUE);
- private final static java.math.BigDecimal bdMinLongValue__ =
- java.math.BigDecimal.valueOf (Long.MIN_VALUE);
- private final static java.math.BigDecimal bdMaxFloatValue__ =
- new java.math.BigDecimal (Float.MAX_VALUE);
- private final static java.math.BigDecimal bdMinFloatValue__ =
- new java.math.BigDecimal (-Float.MAX_VALUE);
- private final static java.math.BigDecimal bdMaxDoubleValue__ =
- new java.math.BigDecimal (Double.MAX_VALUE);
- private final static java.math.BigDecimal bdMinDoubleValue__ =
- new java.math.BigDecimal (-Double.MAX_VALUE);
-
- // Since BigDecimals are immutable, we can return pointers to these canned 0's and 1's.
- private final static java.math.BigDecimal bdZero__ = java.math.BigDecimal.valueOf (0);
- private final static java.math.BigDecimal bdOne__ = java.math.BigDecimal.valueOf (1);
-
- // ---------------------- state ----------------------------------------------
-
- Agent agent_;
-
- // ----------------------constructors/finalizer-------------------------------
-
- CrossConverters (Agent agent)
- {
- agent_ = agent;
- }
-
- // ---------------------------------------------------------------------------
- // The following methods are used for input cross conversion.
- // ---------------------------------------------------------------------------
-
- //---------------------------- setObject() methods ---------------------------
-
- // Convert from boolean source to target type.
- // In support of PS.setBoolean().
- // See differences.html for DNC setBoolean() semantics.
- final Object setObject (int targetType, boolean source) throws SqlException
- {
- return setObject (targetType, (short) (source ? 1 : 0));
- }
-
- // Convert from byte source to target type
- // In support of PS.setByte()
- final Object setObject (int targetType, byte source) throws SqlException
- {
- return setObject (targetType, (short) source);
- }
-
- // Convert from short source to target type
- // In support of PS.setShort()
- final Object setObject (int targetType, short source) throws SqlException
- {
- switch (targetType) {
- case Types.SMALLINT:
- return new Short (source);
-
- case Types.INTEGER:
- return new Integer (source);
-
- case Types.BIGINT:
- return new Long (source);
-
- case Types.REAL:
- return new Float (source);
-
- case Types.DOUBLE:
- return new Double (source);
-
- case Types.DECIMAL:
- return java.math.BigDecimal.valueOf (source);
-
- case Types.CHAR:
- case Types.VARCHAR:
- case Types.LONGVARCHAR:
- return String.valueOf (source);
-
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // Convert from integer source to target type
- // In support of PS.setInt()
- final Object setObject (int targetType, int source) throws SqlException
- {
- switch (targetType) {
- case Types.SMALLINT:
- if (Configuration.rangeCheckCrossConverters &&
- (source > Short.MAX_VALUE || source < Short.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Short ((short) source);
-
- case Types.INTEGER:
- return new Integer (source);
-
- case Types.BIGINT:
- return new Long (source);
-
- case Types.REAL:
- return new Float (source);
-
- case Types.DOUBLE:
- return new Double (source);
-
- case Types.DECIMAL:
- return java.math.BigDecimal.valueOf (source);
-
- case Types.CHAR:
- case Types.VARCHAR:
- case Types.LONGVARCHAR:
- return String.valueOf (source);
-
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // This method is used in lieu of setObject(targetType, sourceObject) because we
- // don't support the BIT/BOOLEAN as underlying DERBY targetTypes.
- final boolean setBooleanFromObject (Object source, int sourceType) throws SqlException
- {
- switch (sourceType) {
- case Types.SMALLINT:
- return getBooleanFromShort (((Short)source).shortValue());
- case Types.INTEGER:
- return getBooleanFromInt (((Integer)source).intValue());
- case Types.BIGINT:
- return getBooleanFromLong (((java.math.BigInteger)source).longValue());
- case Types.REAL:
- return getBooleanFromFloat (((Float)source).floatValue());
- case Types.DOUBLE:
- return getBooleanFromDouble (((Double)source).doubleValue());
- case Types.DECIMAL:
- return getBooleanFromLong (((java.math.BigDecimal)source).longValue());
- case Types.CHAR:
- case Types.VARCHAR:
- case Types.LONGVARCHAR:
- return getBooleanFromString ((String)source);
- default:
- throw new ColumnTypeConversionException (agent_.logWriter_);
- }
- }
-
- // This method is used in lieu of setObject(targetType, sourceObject) because we
- // don't support the BIT/BOOLEAN as underlying DERBY targetTypes.
- final byte setByteFromObject (Object source, int sourceType) throws SqlException
- {
- switch (sourceType) {
- case Types.SMALLINT:
- return getByteFromShort (((Short)source).shortValue());
- case Types.INTEGER:
- return getByteFromInt (((Integer)source).intValue());
- case Types.BIGINT:
- return getByteFromLong (((java.math.BigInteger)source).longValue());
- case Types.REAL:
- return getByteFromFloat (((Float)source).floatValue());
- case Types.DOUBLE:
- return getByteFromDouble (((Double)source).doubleValue());
- case Types.DECIMAL:
- return getByteFromLong (((java.math.BigDecimal)source).longValue());
- case Types.CHAR:
- case Types.VARCHAR:
- case Types.LONGVARCHAR:
- return getByteFromString ((String)source);
- default:
- throw new ColumnTypeConversionException (agent_.logWriter_);
- }
- }
-
- // Convert from long source to target type
- // In support of PS.setLong()
- final Object setObject (int targetType, long source) throws SqlException
- {
- switch (targetType) {
- case Types.SMALLINT:
- if (Configuration.rangeCheckCrossConverters &&
- (source > Short.MAX_VALUE || source < Short.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Short ((short) source);
-
- case Types.INTEGER:
- if (Configuration.rangeCheckCrossConverters &&
- (source > Integer.MAX_VALUE || source < Integer.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Integer ((int) source);
-
- case Types.BIGINT:
- return new Long (source);
-
- case Types.REAL:
- return new Float (source);
-
- case Types.DOUBLE:
- return new Double (source);
-
- case Types.DECIMAL:
- return java.math.BigDecimal.valueOf (source);
-
- case Types.CHAR:
- case Types.VARCHAR:
- case Types.LONGVARCHAR:
- return String.valueOf (source);
-
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // Convert from floating point source to target type
- // In support of PS.setFloat()
- final Object setObject (int targetType, float source) throws SqlException
- {
- switch (targetType) {
- case Types.SMALLINT:
- if (Configuration.rangeCheckCrossConverters &&
- (source > Short.MAX_VALUE || source < Short.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Short ((short) source);
-
- case Types.INTEGER:
- if (Configuration.rangeCheckCrossConverters &&
- (source > Integer.MAX_VALUE || source < Integer.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Integer ((int) source);
-
- case Types.BIGINT:
- if (Configuration.rangeCheckCrossConverters &&
- (source > Long.MAX_VALUE || source < Long.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Long ((long) source);
-
- case Types.REAL:
- if (Configuration.rangeCheckCrossConverters &&
- // change the check from (source > Float.MAX_VALUE || source < -Float.MIN_VALUE))
- // to the following:
- //-----------------------------------------------------------------------------------
- // -infinity 0 +infinity
- // |__________________________|======|________________________|
- // <-3.4E+38| | | |>+3.4E+38
- // | | |_________________ |
- // | |-1.4E-45 <X< +1.4E-45
- // | |________________________
- //-----------------------------------------------------------------------------------
- (source == Float.POSITIVE_INFINITY || source == Float.NEGATIVE_INFINITY))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Float (source);
-
- case Types.DOUBLE:
- if (Configuration.rangeCheckCrossConverters &&
- //-------------------------------------------------------------------------------------
- // -infinity 0 +infinity
- // |__________________________|======|________________________|
- // <-1.79E+308| | | |>+1.79E+308
- // | | |_________________ |
- // | |-4.9E-324 <X< +4.9E-324
- // | |________________________
- //-------------------------------------------------------------------------------------
- (source == Double.POSITIVE_INFINITY || source == Double.NEGATIVE_INFINITY))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- // source passed in is a float, do we need to check if the source already contains "infinity"??
- return new Double (String.valueOf(source));
-
- case Types.DECIMAL:
- // Can't use the following commented out line because it changes precision of the result.
- //return new java.math.BigDecimal (source);
- return new java.math.BigDecimal (String.valueOf (source)); // This matches derby semantics
-
- case Types.CHAR:
- case Types.VARCHAR:
- case Types.LONGVARCHAR:
- return String.valueOf (source);
-
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // Convert from double floating point source to target type
- // In support of PS.setDouble()
- final Object setObject (int targetType, double source) throws SqlException
- {
- switch (targetType) {
- case Types.SMALLINT:
- if (Configuration.rangeCheckCrossConverters &&
- (source > Short.MAX_VALUE || source < Short.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Short ((short) source);
-
- case Types.INTEGER:
- if (Configuration.rangeCheckCrossConverters &&
- (source > Integer.MAX_VALUE || source < Integer.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Integer ((int) source);
-
- case Types.BIGINT:
- if (Configuration.rangeCheckCrossConverters &&
- (source > Long.MAX_VALUE || source < Long.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Long ((long) source);
-
- case Types.REAL:
- if (Configuration.rangeCheckCrossConverters &&
- (source > Float.MAX_VALUE || source < -Float.MAX_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Float ((float) source);
-
- case Types.DOUBLE:
- if (Configuration.rangeCheckCrossConverters &&
- // change the check from (source > Double.MAX_VALUE || source < -Double.MIN_VALUE))
- // to the following:
- //-------------------------------------------------------------------------------------
- // -infinity 0 +infinity
- // |__________________________|======|________________________|
- // <-1.79E+308| | | |>+1.79E+308
- // | | |_________________ |
- // | |-4.9E-324 <X< +4.9E-324
- // | |________________________
- //-------------------------------------------------------------------------------------
- (source == Double.POSITIVE_INFINITY || source == Double.NEGATIVE_INFINITY))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Double (source);
-
- case Types.DECIMAL:
- return new java.math.BigDecimal (String.valueOf (source)); // This matches derby semantics
- case Types.CHAR:
- case Types.VARCHAR:
- case Types.LONGVARCHAR:
- return String.valueOf (source);
-
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // Convert from big decimal source to target type
- // In support of PS.setBigDecimal()
- final Object setObject (int targetType, java.math.BigDecimal source) throws SqlException
- {
- switch (targetType) {
- case Types.SMALLINT:
- if (Configuration.rangeCheckCrossConverters &&
- (source.compareTo (bdMaxShortValue__) == 1 || source.compareTo (bdMinShortValue__) == -1))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Short (source.shortValue());
-
- case Types.INTEGER:
- if (Configuration.rangeCheckCrossConverters &&
- (source.compareTo (bdMaxIntValue__) == 1 || source.compareTo (bdMinIntValue__) == -1))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Integer (source.intValue());
-
- case Types.BIGINT:
- if (Configuration.rangeCheckCrossConverters &&
- (source.compareTo (bdMaxLongValue__) == 1 || source.compareTo (bdMinLongValue__) == -1))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Long (source.longValue());
-
- case Types.REAL:
- if (Configuration.rangeCheckCrossConverters &&
- (source.compareTo (bdMaxFloatValue__) == 1 || source.compareTo (bdMinFloatValue__) == -1))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Float (source.floatValue());
-
- case Types.DOUBLE:
- if (Configuration.rangeCheckCrossConverters &&
- (source.compareTo (bdMaxDoubleValue__) == 1 || source.compareTo (bdMinDoubleValue__) == -1))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return new Double (source.doubleValue());
-
- case Types.DECIMAL:
- return source;
-
- case Types.CHAR:
- case Types.VARCHAR:
- case Types.LONGVARCHAR:
- return String.valueOf (source);
-
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // Convert from date source to target type
- // In support of PS.setDate()
- final Object setObject (int targetType, java.sql.Date source) throws SqlException
- {
- switch (targetType) {
-
- case java.sql.Types.DATE:
- return source;
-
- case java.sql.Types.TIMESTAMP:
- return new java.sql.Timestamp (source.getTime());
-
- case java.sql.Types.CHAR:
- case java.sql.Types.VARCHAR:
- case java.sql.Types.LONGVARCHAR:
- return String.valueOf (source);
-
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // Convert from time source to target type
- // In support of PS.setTime()
- final Object setObject (int targetType, java.sql.Time source) throws SqlException
- {
- switch (targetType) {
-
- case java.sql.Types.TIME:
- return source;
-
- case java.sql.Types.CHAR:
- case java.sql.Types.VARCHAR:
- case java.sql.Types.LONGVARCHAR:
- return String.valueOf (source);
-
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // Convert from date source to target type
- // In support of PS.setTimestamp()
- final Object setObject (int targetType, java.sql.Timestamp source) throws SqlException
- {
- switch (targetType) {
-
- case java.sql.Types.TIMESTAMP:
- return source;
-
- case java.sql.Types.TIME:
- return new java.sql.Time (source.getTime());
-
- case java.sql.Types.DATE:
- return new java.sql.Date (source.getTime());
-
- case java.sql.Types.CHAR:
- case java.sql.Types.VARCHAR:
- case java.sql.Types.LONGVARCHAR:
- return String.valueOf (source);
-
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // setString() against BINARY columns cannot be implemented consistently because w/out metadata, we'll send char encoding bytes.
- // So we refuse setString() requests altogether.
- // Convert from string source to target type.
- // In support of PS.setString()
- final Object setObject (int targetDriverType, String source) throws SqlException
- {
- try {
- switch (targetDriverType) {
- case Types.SMALLINT:
- return Short.valueOf (source);
-
- case Types.INTEGER:
- return Integer.valueOf (source);
-
- case Types.BIGINT:
- return Long.valueOf (source);
-
- case Types.REAL:
- return Float.valueOf (source);
-
- case Types.DOUBLE:
- return Double.valueOf (source);
-
- case Types.DECIMAL:
- return new java.math.BigDecimal (source);
-
- case java.sql.Types.DATE:
- return date_valueOf (source);
-
- case java.sql.Types.TIME:
- return time_valueOf (source);
-
- case java.sql.Types.TIMESTAMP:
- return timestamp_valueOf (source);
-
- case Types.CHAR:
- case Types.VARCHAR:
- case Types.LONGVARCHAR:
- return source;
-
- case Types.CLOB:
- return new Clob (agent_, source);
-
- // setString() against BINARY columns is problematic because w/out metadata, we'll send char encoding bytes.
- // So we refuse setString() requests altogether.
- case Types.BINARY:
- case Types.VARBINARY:
- case Types.LONGVARBINARY:
- case Types.BLOB:
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
- catch (java.lang.NumberFormatException e) {
- throw new SqlException(
- agent_.logWriter_,
- e,
- "Invalid data conversion:"
- + " Parameter instance "
- + source
- + " is invalid for requested conversion.");
- }
- }
-
- // -- methods in support of setObject(String)/getString() on BINARY columns---
-
-
- // Convert from byte[] source to target type
- // In support of PS.setBytes()
- final Object setObject (int targetType, byte[] source) throws SqlException
- {
- switch (targetType) {
- case Types.BINARY:
- case Types.VARBINARY:
- case Types.LONGVARBINARY:
- return source;
- case Types.BLOB:
- return new Blob (source, agent_, 0);
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // Convert from Reader source to target type
- // In support of PS.setCharacterStream()
- final Object setObject (int targetType, java.io.Reader source, int length) throws SqlException
- {
- switch (targetType) {
- case Types.CHAR:
- case Types.VARCHAR:
- case Types.LONGVARCHAR:
- return setStringFromReader (source, length);
- case Types.CLOB:
- return new Clob (agent_, source, length);
- // setCharacterStream() against BINARY columns is problematic because w/out metadata, we'll send char encoding bytes.
- // There's no clean solution except to just not support setObject(String/Reader/Stream)
- case Types.BINARY:
- case Types.VARBINARY:
- case Types.LONGVARBINARY:
- case Types.BLOB:
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // create a String by reading all of the bytes from reader
- private final String setStringFromReader (java.io.Reader r, int length) throws SqlException
- {
- java.io.StringWriter sw = new java.io.StringWriter ();
- try {
- int read = r.read ();
- int totalRead = 0;
- while (read != -1) {
- totalRead++;
- sw.write (read);
- read = r.read ();
- }
- if (length != totalRead) {
- throw new SqlException (agent_.logWriter_, "The Reader object does not contain length characters");
- }
- return sw.toString ();
- }
- catch (java.io.IOException e) {
- throw new SqlException (agent_.logWriter_, e.getMessage ());
- }
- }
-
- // Convert from InputStream source to target type.
- // In support of PS.setAsciiStream, PS.setUnicodeStream
- // Note: PS.setCharacterStream() is handled by setObject(Reader)
- final Object setObjectFromCharacterStream (int targetType, java.io.InputStream source, String encoding, int length) throws SqlException
- {
- switch (targetType) {
- case Types.CHAR:
- case Types.VARCHAR:
- case Types.LONGVARCHAR:
- return setStringFromStream (source, encoding, length);
- case Types.CLOB:
- return new Clob (agent_, source, encoding, length);
- case Types.BINARY:
- case Types.VARBINARY:
- case Types.LONGVARBINARY:
- case Types.BLOB:
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
-
- // create a String by reading all of the bytes from inputStream, applying encoding
- private final String setStringFromStream (java.io.InputStream is, String encoding, int length) throws SqlException
- {
- try {
- java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream ();
- int totalRead = 0;
-
- try {
- int read = is.read ();
- while (read != -1) {
- totalRead++;
- baos.write (read);
- read = is.read ();
- }
- }
- catch (java.io.IOException e) {
- throw new SqlException (agent_.logWriter_, e.getMessage ());
- }
-
- if (length != totalRead) {
- throw new SqlException (agent_.logWriter_, "The InputStream object does not contain length bytes");
- }
-
- return new String (baos.toByteArray(), encoding);
- }
- catch (java.io.UnsupportedEncodingException e) {
- throw new SqlException (agent_.logWriter_, e.getMessage ());
- }
- }
-
- // Convert from Blob source to target type
- // In support of PS.setBlob()
- final Object setObject (int targetType, java.sql.Blob source) throws SqlException
- {
- switch (targetType) {
- case Types.BLOB:
- return source;
- case Types.BINARY:
- case Types.VARBINARY:
- case Types.LONGVARBINARY:
- try {
- return source.getBytes(1L, (int) source.length());
- }
- catch (java.sql.SQLException e)
- {
- throw new SqlException (agent_.logWriter_, e.getMessage ());
- }
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // Convert from InputStream source to target type
- // In support of PS.setBinaryStream()
- final Object setObjectFromBinaryStream (int targetType, java.io.InputStream source, int length) throws SqlException
- {
- switch (targetType) {
- case Types.BINARY:
- case Types.VARBINARY:
- case Types.LONGVARBINARY:
- return setBytesFromStream (source, length);
- case Types.BLOB:
- return new Blob (agent_, source, length);
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // create a byte[] by reading all of the bytes from inputStream
- private final byte[] setBytesFromStream (java.io.InputStream is, int length) throws SqlException
- {
- java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream ();
- int totalRead = 0;
-
- try {
- int read = is.read ();
- while (read != -1) {
- totalRead++;
- baos.write (read);
- read = is.read ();
- }
-
- if (length != totalRead) {
- throw new SqlException (agent_.logWriter_, "The InputStream object does not contain length bytes");
- }
- }
- catch (java.io.IOException e) {
- throw new SqlException (agent_.logWriter_, e.getMessage ());
- }
- return baos.toByteArray ();
- }
-
- // Convert from Clob source to target type
- // In support of PS.setClob()
- final Object setObject (int targetType, java.sql.Clob source) throws SqlException
- {
- switch (targetType) {
- case Types.CLOB:
- return source;
- case Types.CHAR:
- case Types.VARCHAR:
- case Types.LONGVARCHAR:
- return source.toString();
- default:
- throw new SqlException (agent_.logWriter_, "Illegal Conversion");
- }
- }
-
- // The Java compiler uses static binding, so we can't rely on the strongly
- // typed setObject() methods above for each of the Java Object instance types.
- final Object setObject (int targetType, Object source) throws SqlException
- {
- if (source instanceof Boolean) return setObject (targetType, ((Boolean) source).booleanValue());
- else if (source instanceof Integer) return setObject (targetType, ((Integer) source).intValue());
- else if (source instanceof Long) return setObject (targetType, ((Long) source).longValue());
- else if (source instanceof Float) return setObject (targetType, ((Float) source).floatValue());
- else if (source instanceof Double) return setObject (targetType, ((Double) source).doubleValue());
- else if (source instanceof java.math.BigDecimal) return setObject (targetType, (java.math.BigDecimal) source);
- else if (source instanceof java.sql.Date) return setObject (targetType, (java.sql.Date) source);
- else if (source instanceof java.sql.Time) return setObject (targetType, (java.sql.Time) source);
- else if (source instanceof java.sql.Timestamp) return setObject (targetType, (java.sql.Timestamp) source);
- else if (source instanceof String) return setObject (targetType, (String) source);
- else if (source instanceof byte[]) return setObject (targetType, (byte[]) source);
- else if (source instanceof java.sql.Blob) return setObject (targetType, (java.sql.Blob) source);
- else if (source instanceof java.sql.Clob) return setObject (targetType, (java.sql.Clob) source);
- else if (source instanceof java.sql.Array) return setObject (targetType, (java.sql.Array) source);
- else if (source instanceof java.sql.Ref) return setObject (targetType, (java.sql.Ref) source);
- else if (source instanceof Short) return setObject (targetType, ((Short) source).shortValue());
- else if (source instanceof Byte) return setObject (targetType, ((Byte) source).byteValue());
- else {
- throw new SqlException (agent_.logWriter_, "Invalid data conversion:" +
- " Parameter instance " + source +
- " is invalid for requested conversion.");
- }
- }
-
- // move all these to Cursor and rename to crossConvertFrom*To*()
- // ---------------------------------------------------------------------------
- // The following methods are used for output cross conversion.
- // ---------------------------------------------------------------------------
-
- //---------------------------- getBoolean*() methods -------------------------
-
- final boolean getBooleanFromByte (byte source) throws SqlException
- {
- return source != 0;
- }
-
- final boolean getBooleanFromShort (short source) throws SqlException
- {
- return source != 0;
- }
-
- final boolean getBooleanFromInt (int source) throws SqlException
- {
- return source != 0;
- }
-
- final boolean getBooleanFromLong (long source) throws SqlException
- {
- return source != 0;
- }
-
- final boolean getBooleanFromFloat (float source) throws SqlException
- {
- return source != 0;
- }
-
- final boolean getBooleanFromDouble (double source) throws SqlException
- {
- return source != 0;
- }
-
- final boolean getBooleanFromBigDecimal (java.math.BigDecimal source) throws SqlException
- {
- return source.intValue() != 0;
- }
-
- // See differences.html for DNC getBoolean() semantics.
- final boolean getBooleanFromString (String source) throws SqlException
- {
- return ! (source.trim().equals ("0") || source.trim().equals ("false"));
- }
-
- //---------------------------- getByte*() methods ----------------------------
-
- final byte getByteFromShort (short source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Byte.MAX_VALUE || source < java.lang.Byte.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (byte) source;
- }
-
- final byte getByteFromInt (int source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Byte.MAX_VALUE || source < java.lang.Byte.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (byte) source;
- }
-
- final byte getByteFromLong (long source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Byte.MAX_VALUE || source < java.lang.Byte.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (byte) source;
- }
-
- final byte getByteFromFloat (float source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Byte.MAX_VALUE || source < java.lang.Byte.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (byte) source;
- }
-
- final byte getByteFromDouble (double source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Byte.MAX_VALUE || source < java.lang.Byte.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (byte) source;
- }
-
- final byte getByteFromBigDecimal (java.math.BigDecimal source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source.compareTo (bdMaxByteValue__) == 1 || source.compareTo (bdMinByteValue__) == -1))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return (byte) source.intValue();
- }
-
- final byte getByteFromBoolean (boolean source) throws SqlException
- {
- return source ? (byte) 1 : (byte) 0;
- }
-
- final byte getByteFromString (String source) throws SqlException
- {
- try {
- return parseByte (source);
- }
- catch (java.lang.NumberFormatException e) {
- throw new SqlException (agent_.logWriter_, e, "Invalid data conversion:" +
- " Parameter instance " + source +
- " is invalid for requested conversion to " + "byte.");
- }
- }
-
- //---------------------------- getShort*() methods ---------------------------
-
- final short getShortFromInt (int source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Short.MAX_VALUE || source < java.lang.Short.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (short) source;
- }
-
- final short getShortFromLong (long source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Short.MAX_VALUE || source < java.lang.Short.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (short) source;
- }
-
- final short getShortFromFloat (float source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Short.MAX_VALUE || source < java.lang.Short.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (short) source;
- }
-
- final short getShortFromDouble (double source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Short.MAX_VALUE || source < java.lang.Short.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (short) source;
- }
-
- final short getShortFromBigDecimal (java.math.BigDecimal source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source.compareTo (bdMaxShortValue__) == 1 || source.compareTo (bdMinShortValue__) == -1))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return (short) source.intValue();
- }
-
- final short getShortFromBoolean (boolean source) throws SqlException
- {
- return source ? (short) 1 : (short) 0;
- }
-
- final short getShortFromString (String source) throws SqlException
- {
- try {
- return parseShort (source);
- }
- catch (java.lang.NumberFormatException e) {
- throw new SqlException (agent_.logWriter_, e, "Invalid data conversion:" +
- " Parameter instance " + source +
- " is invalid for requested conversion to " + "short.");
- }
- }
-
- //---------------------------- getInt*() methods -----------------------------
-
- final int getIntFromLong (long source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Integer.MAX_VALUE || source < java.lang.Integer.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (int) source;
- }
-
- final int getIntFromFloat (float source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Integer.MAX_VALUE || source < java.lang.Integer.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (int) source;
- }
-
- final int getIntFromDouble (double source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Integer.MAX_VALUE || source < java.lang.Integer.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (int) source;
- }
-
- final int getIntFromBigDecimal (java.math.BigDecimal source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source.compareTo (bdMaxIntValue__) == 1 || source.compareTo (bdMinIntValue__) == -1))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return source.intValue();
- }
-
- final int getIntFromBoolean (boolean source) throws SqlException
- {
- return source ? (int) 1 : (int) 0;
- }
-
- final int getIntFromString (String source) throws SqlException
- {
- try {
- return parseInt (source);
- }
- catch (java.lang.NumberFormatException e) {
- throw new SqlException (agent_.logWriter_, e, "Invalid data conversion:" +
- " Parameter instance " + source +
- " is invalid for requested conversion to " + "int.");
- }
- }
-
- //---------------------------- getLong*() methods ----------------------------
-
- final long getLongFromFloat (float source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Long.MAX_VALUE || source < java.lang.Long.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (long) source;
- }
-
- final long getLongFromDouble (double source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > java.lang.Long.MAX_VALUE || source < java.lang.Long.MIN_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (long) source;
- }
-
- final long getLongFromBigDecimal (java.math.BigDecimal source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source.compareTo (bdMaxLongValue__) == 1 || source.compareTo (bdMinLongValue__) == -1))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return source.longValue();
- }
-
- final long getLongFromBoolean (boolean source) throws SqlException
- {
- return source ? (long) 1 : (long) 0;
- }
-
- final long getLongFromString (String source) throws SqlException
- {
- try {
- return parseLong (source);
- }
- catch (java.lang.NumberFormatException e) {
- throw new SqlException (agent_.logWriter_, e, "Invalid data conversion:" +
- " Parameter instance " + source +
- " is invalid for requested conversion to " + "long.");
- }
- }
-
- //---------------------------- getFloat*() methods ---------------------------
-
- final float getFloatFromDouble (double source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source > Float.MAX_VALUE || source < -Float.MAX_VALUE))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
-
- return (float) source;
- }
-
- final float getFloatFromBigDecimal (java.math.BigDecimal source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source.compareTo (bdMaxFloatValue__) == 1 || source.compareTo (bdMinFloatValue__) == -1))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return source.floatValue();
- }
-
- final float getFloatFromBoolean (boolean source) throws SqlException
- {
- return source ? (float) 1 : (float) 0;
- }
-
- final float getFloatFromString (String source) throws SqlException
- {
- try {
- return Float.parseFloat (source.trim());
- }
- catch (java.lang.NumberFormatException e) {
- throw new SqlException (agent_.logWriter_, e, "Invalid data conversion:" +
- " Parameter instance " + source +
- " is invalid for requested conversion to " + "float.");
- }
- }
-
- //---------------------------- getDouble*() methods --------------------------
-
- final double getDoubleFromBigDecimal (java.math.BigDecimal source) throws SqlException
- {
- if (Configuration.rangeCheckCrossConverters &&
- (source.compareTo (bdMaxDoubleValue__) == 1 || source.compareTo (bdMinDoubleValue__) == -1))
- throw new LossOfPrecisionConversionException (agent_.logWriter_, String.valueOf (source));
- return source.doubleValue();
- }
-
- final double getDoubleFromBoolean (boolean source) throws SqlException
- {
- return source ? (double) 1 : (double) 0;
- }
-
- final double getDoubleFromString (String source) throws SqlException
- {
- try {
- return Double.parseDouble (source.trim());
- }
- catch (java.lang.NumberFormatException e) {
- throw new SqlException (agent_.logWriter_, e, "Invalid data conversion:" +
- " Parameter instance " + source +
- " is invalid for requested conversion to " + "double.");
- }
- }
-
- //---------------------------- getBigDecimal*() methods ----------------------
-
- final java.math.BigDecimal getBigDecimalFromBoolean (boolean source) throws SqlException
- {
- return source ? bdOne__ : bdZero__;
- }
-
- final java.math.BigDecimal getBigDecimalFromString (String source) throws SqlException
- {
- try {
- // Unfortunately, the big decimal constructor calls java.lang.Long.parseLong(),
- // which doesn't like spaces, so we have to call trim() to get rid of the spaces from CHAR columns.
- return new java.math.BigDecimal (source.trim());
- }
- catch (java.lang.NumberFormatException e) {
- throw new SqlException (agent_.logWriter_, e, "Invalid data conversion:" +
- " Parameter instance " + source +
- " is invalid for requested conversion to " + "java.math.BigDecimal.");
- }
- }
-
- //---------------------------- getString*() methods --------------------------
-
- final String getStringFromBoolean (boolean source) throws SqlException
- {
- return source ? "1" : "0";
- }
-
- final String getStringFromBytes (byte[] bytes) throws SqlException
- {
- StringBuffer stringBuffer = new StringBuffer (bytes.length*2);
- for (int i=0; i < bytes.length; i++) {
- String hexForByte = Integer.toHexString (bytes[i] & 0xff);
- // If the byte is x0-F, prepend a "0" in front to ensure 2 char representation
- if (hexForByte.length() == 1) stringBuffer.append ('0');
- stringBuffer.append (hexForByte);
- }
- return stringBuffer.toString();
- }
-
-
- // All Numeric, and Date/Time types use String.valueOf (source)
-
- //---------------------------- getDate*() methods ----------------------------
-
- final java.sql.Date getDateFromString (String source) throws SqlException
- {
- try {
- // We override the JRE's Date.valueOf() in order to support a more Extended ISO format as requested by Toronto team
- return date_valueOf (source);
- }
- catch (java.lang.IllegalArgumentException e) { // subsumes NumberFormatException
- throw new SqlException (agent_.logWriter_, e, "Invalid data conversion:" +
- " Parameter instance " + source +
- " is invalid for requested conversion to " + "java.sql.Date.");
- }
- }
-
- final java.sql.Date getDateFromTime (java.sql.Time source) throws SqlException
- {
- return new java.sql.Date (source.getTime());
- }
-
- final java.sql.Date getDateFromTimestamp (java.sql.Timestamp source) throws SqlException
- {
- return new java.sql.Date (source.getTime());
- }
-
- //---------------------------- getTime*() methods ----------------------------
-
- final java.sql.Time getTimeFromString (String source) throws SqlException
- {
- try {
- // We override the JRE's Time.valueOf() in order to support a more Extended ISO format as requested by Toronto team
- return time_valueOf (source);
- }
- catch (java.lang.IllegalArgumentException e) { // subsumes NumberFormatException
- throw new SqlException (agent_.logWriter_, e, "Invalid data conversion:" +
- " Parameter instance " + source +
- " is invalid for requested conversion to " + "java.sql.Time.");
- }
- }
-
- final java.sql.Time getTimeFromTimestamp (java.sql.Timestamp source) throws SqlException
- {
- return new java.sql.Time (source.getTime());
- }
-
- //---------------------------- getTimestamp*() methods -----------------------
-
- final java.sql.Timestamp getTimestampFromString (String source) throws SqlException
- {
- try {
- // We override the JRE's Timestamp.valueOf() in order to support a more Extended ISO format as requested by Toronto team
- return timestamp_valueOf (source);
- }
- catch (java.lang.IllegalArgumentException e) { // subsumes NumberFormatException
- throw new SqlException (agent_.logWriter_, e,
- "Invalid data conversion:" +
- " Parameter instance " + source +
- " is invalid for requested conversion to " + "java.sql.Timestamp.");
- }
- }
-
- final java.sql.Timestamp getTimestampFromTime (java.sql.Time source) throws SqlException
- {
- return new java.sql.Timestamp (source.getTime());
- }
-
- final java.sql.Timestamp getTimestampFromDate(java.sql.Date source) throws SqlException
- {
- return new java.sql.Timestamp (source.getTime());
- }
-
- //-------------- Customized versions of java.lang parse methods --------------
-
- // Converts a string in JDBC date "extended" ISO format to a Date value.
- // yyyy-mm-dd with trailing blanks allowed.
- final java.sql.Date date_valueOf (String s) throws java.lang.IllegalArgumentException
- {
- String formatError = "JDBC Date format must be yyyy-mm-dd";
- if (s == null) throw new java.lang.IllegalArgumentException (formatError);
-
- int year = 1000*getDigit (s, 0);
- year += 100*getDigit (s, 1);
- year += 10*getDigit (s, 2);
- year += 1*getDigit (s, 3);
-
- char hyphen = s.charAt (4);
- if (hyphen != '-') throw new java.lang.IllegalArgumentException (formatError);
-
- int month =0;
- int day = 0;
- int pos =0;
-
- hyphen = s.charAt (6);
- if(hyphen == '-') { //single digit month
- month = getDigit (s, 5);
- pos = 7;
- }
- else { //double digit month
- month = 10 * getDigit (s, 5);
- month += 1*getDigit (s, 6);
- pos = 8;
- hyphen = s.charAt (7);
- if (hyphen != '-') throw new java.lang.IllegalArgumentException (formatError);
- }
-
- if(s.length() == (pos + 1) || Character.digit(s.charAt(pos +1), 10) == -1) { //single digit day
- day = getDigit (s, pos);
- pos ++;
- }
- else { //double digit day
- day = 10 * getDigit (s, pos);
- day += 1* getDigit (s, pos + 1);
- pos = pos + 2;
- }
- skipPadding (s, pos, s.length());
- return new java.sql.Date (year-1900, month-1, day);
- }
-
- // Customized versions of java.util.Date/Time/Timestamp valueOf methods
- // We override the JRE's Date/Time/Timestamp.valueOf() methods in order to support a
- // more Extended ISO format as requested by Toronto team.
- // Also allows for space-padding of CHAR fields.
-
- private final int getDigit (String s, int index) throws java.lang.IllegalArgumentException
- {
- String formatError = "Date/Time must be JDBC format";
- int digit = -1 ;
- if (s != null && s.length() >= 10)
- digit = Character.digit (s.charAt (index), 10);
- if (digit == -1) throw new java.lang.IllegalArgumentException (formatError);
- return digit;
- }
-
- // Converts a string in JDBC time "extended" ISO format to a Time value.
- // hh:mm:ss or hh.mm.ss with trailing blanks allowed.
- final java.sql.Time time_valueOf (String s) throws java.lang.IllegalArgumentException, NumberFormatException
- {
- String formatError = "JDBC Time format must be hh:mm:ss";
- if (s == null) throw new java.lang.IllegalArgumentException();
-
- int hour = 10*getDigit (s, 0);
- hour += 1*getDigit (s, 1);
-
- char colon = s.charAt(2);
- if (colon != ':' && colon != '.') throw new java.lang.IllegalArgumentException (formatError);
-
- int minute = 10*getDigit (s, 3);
- minute += 1*getDigit (s, 4);
-
- colon = s.charAt(5);
- if (colon != ':' && colon != '.') throw new java.lang.IllegalArgumentException (formatError);
-
- int second = 10*getDigit (s, 6);
- second += 1*getDigit (s, 7);
-
- skipPadding (s, 8, s.length());
- return new java.sql.Time (hour, minute, second);
- }
-
- // Converts a string in JDBC date "extended" ISO format to a Timestamp value.
- // yyyy-mm-dd hh:mm:ss[.[n[n[n[n[n[n[n[n[n]]]]]]]] or yyyy-mm-dd-hh.mm.ss[.[n[n[n[n[n[n[n[n[n]]]]]]]] with trailing blanks allowed.
- final java.sql.Timestamp timestamp_valueOf (String s) throws java.lang.IllegalArgumentException, NumberFormatException
- {
- String formatError = "JDBC Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff";
- if (s == null) throw new java.lang.IllegalArgumentException();
-
- int year = 1000*getDigit (s, 0);
- year += 100*getDigit (s, 1);
- year += 10*getDigit (s, 2);
- year += 1*getDigit (s, 3);
-
- char hyphen = s.charAt (4);
- if (hyphen != '-') throw new java.lang.IllegalArgumentException (formatError);
-
- int month = 10*getDigit (s, 5);
- month += 1*getDigit (s, 6);
-
- hyphen = s.charAt (7);
- if (hyphen != '-') throw new java.lang.IllegalArgumentException (formatError);
-
- int day = 10*getDigit (s, 8);
- day += 1*getDigit (s, 9);
-
- char space = s.charAt (10);
- if (space != ' ' && space != '-') throw new java.lang.IllegalArgumentException (formatError);
-
- int hour = 10*getDigit (s, 11);
- hour += 1*getDigit (s, 12);
-
- char colon = s.charAt (13);
- if (colon != ':' && colon != '.') throw new java.lang.IllegalArgumentException (formatError);
-
- int minute = 10*getDigit (s, 14);
- minute += 1*getDigit (s, 15);
-
- colon = s.charAt(16);
- if (colon != ':' && colon != '.') throw new java.lang.IllegalArgumentException (formatError);
-
- int second = 10*getDigit (s, 17);
- second += 1*getDigit (s, 18);
-
- if (s.trim().length() == 19) return new java.sql.Timestamp (year-1900, month-1, day, hour, minute, second, 0);
-
- char period = s.charAt (19);
- if (period != '.') throw new java.lang.IllegalArgumentException (formatError);
- if (s.length() == 20 || s.charAt(20) == ' ') {
- skipPadding (s, 20, s.length());
- return new java.sql.Timestamp (year-1900, month-1, day, hour, minute, second, 0);
- }
-
- // We can put the following into a while loop later....
-
- int digit = Character.digit (s.charAt(20), 10);
- if (digit == -1) throw new java.lang.IllegalArgumentException (formatError);
- int nanos = 100000000*digit;
- if (s.length() == 21 || s.charAt(21) == ' ') {
- skipPadding (s, 21, s.length());
- return new java.sql.Timestamp (year-1900, month-1, day, hour, minute, second, nanos);
- }
-
- digit = Character.digit (s.charAt(21), 10);
- if (digit == -1) throw new java.lang.IllegalArgumentException (formatError);
- nanos += 10000000*digit;
- if (s.length() == 22 || s.charAt(22) == ' ') {
- skipPadding (s, 22, s.length());
- return new java.sql.Timestamp (year-1900, month-1, day, hour, minute, second, nanos);
- }
-
- digit = Character.digit (s.charAt(22), 10);
- if (digit == -1) throw new java.lang.IllegalArgumentException (formatError);
- nanos += 1000000*digit;
- if (s.length() == 23 || s.charAt(23) == ' ') {
- skipPadding (s, 23, s.length());
- return new java.sql.Timestamp (year-1900, month-1, day, hour, minute, second, nanos);
- }
-
- digit = Character.digit (s.charAt(23), 10);
- if (digit == -1) throw new java.lang.IllegalArgumentException (formatError);
- nanos += 100000*digit;
- if (s.length() == 24 || s.charAt(24) == ' ') {
- skipPadding (s, 24, s.length());
- return new java.sql.Timestamp (year-1900, month-1, day, hour, minute, second, nanos);
- }
-
- digit = Character.digit (s.charAt(24), 10);
- if (digit == -1) throw new java.lang.IllegalArgumentException (formatError);
- nanos += 10000*digit;
- if (s.length() == 25 || s.charAt(25) == ' ') {
- skipPadding (s, 25, s.length());
- return new java.sql.Timestamp (year-1900, month-1, day, hour, minute, second, nanos);
- }
-
- digit = Character.digit (s.charAt(25), 10);
- if (digit == -1) throw new java.lang.IllegalArgumentException (formatError);
- nanos += 1000*digit;
- if (s.length() == 26 || s.charAt(26) == ' ') {
- skipPadding (s, 26, s.length());
- return new java.sql.Timestamp (year-1900, month-1, day, hour, minute, second, nanos);
- }
-
- digit = Character.digit (s.charAt(26), 10);
- if (digit == -1) throw new java.lang.IllegalArgumentException (formatError);
- nanos += 100*digit;
- if (s.length() == 27 || s.charAt(27) == ' ') {
- skipPadding (s, 27, s.length());
- return new java.sql.Timestamp (year-1900, month-1, day, hour, minute, second, nanos);
- }
-
- digit = Character.digit (s.charAt(27), 10);
- if (digit == -1) throw new java.lang.IllegalArgumentException (formatError);
- nanos += 10*digit;
- if (s.length() == 28 || s.charAt(28) == ' ') {
- skipPadding (s, 28, s.length());
- return new java.sql.Timestamp (year-1900, month-1, day, hour, minute, second, nanos);
- }
-
- digit = Character.digit (s.charAt(28), 10);
- if (digit == -1) throw new java.lang.IllegalArgumentException (formatError);
- nanos += 1*digit;
- if (s.length() == 29 || s.charAt(29) == ' ') {
- skipPadding (s, 29, s.length());
- return new java.sql.Timestamp (year-1900, month-1, day, hour, minute, second, nanos);
- }
-
- throw new java.lang.IllegalArgumentException (formatError);
- }
-
- private final byte parseByte (String s) throws NumberFormatException
- {
- int i = parseInt (s);
- if (i < Byte.MIN_VALUE || i > Byte.MAX_VALUE)
- throw new NumberFormatException();
- return (byte) i;
- }
-
- private final short parseShort (String s) throws NumberFormatException
- {
- int i = parseInt (s);
- if (i < Short.MIN_VALUE || i > Short.MAX_VALUE)
- throw new NumberFormatException();
- return (short) i;
- }
-
- // Custom version of java.lang.parseInt() that allows for space padding of char fields.
- private final int parseInt (String s) throws NumberFormatException
- {
- if (s == null)
- throw new NumberFormatException ("null");
-
- int result = 0;
- boolean negative = false;
- int i = 0;
- int max = s.length();
- int limit;
- int multmin;
- int digit;
-
- if (max == 0)
- throw new NumberFormatException (s);
-
- if (s.charAt (0) == '-') {
- negative = true;
- limit = Integer.MIN_VALUE;
- i++;
- }
- else {
- limit = -Integer.MAX_VALUE;
- }
- multmin = limit / 10;
- // Special handle the first digit to get things started.
- if (i < max) {
- digit = Character.digit (s.charAt (i++), 10);
- if (digit < 0) {
- throw new NumberFormatException (s);
- }
- else {
- result = -digit;
- }
- }
- // Now handle all the subsequent digits or space padding.
- while (i < max) {
- char c = s.charAt (i++);
- if (c == ' ') {
- skipPadding (s, i, max);
- break;
- }
- // Accumulating negatively avoids surprises near MAX_VALUE
- digit = Character.digit (c, 10);
- if (digit < 0) {
- throw new NumberFormatException (s);
- }
- if (result < multmin) {
- throw new NumberFormatException (s);
- }
- result *= 10;
- if (result < limit + digit) {
- throw new NumberFormatException (s);
- }
- result -= digit;
- }
- if (negative) {
- if (i > 1) {
- return result;
- }
- else { // Only got "-"
- throw new NumberFormatException (s);
- }
- }
- else {
- return -result;
- }
- }
-
- private final long parseLong (String s) throws NumberFormatException
- {
- if (s == null) {
- throw new NumberFormatException ("null");
- }
-
- long result = 0;
- boolean negative = false;
- int i = 0, max = s.length();
- long limit;
- long multmin;
- int digit;
-
- if (max == 0)
- throw new NumberFormatException (s);
-
- if (s.charAt(0) == '-') {
- negative = true;
- limit = Long.MIN_VALUE;
- i++;
- }
- else {
- limit = -Long.MAX_VALUE;
- }
- multmin = limit / 10;
- if (i < max) {
- digit = Character.digit (s.charAt (i++), 10);
- if (digit < 0) {
- throw new NumberFormatException(s);
- }
- else {
- result = -digit;
- }
- }
- while (i < max) {
- char c = s.charAt (i++);
- if (c == ' ') {
- skipPadding (s, i, max);
- break;
- }
- // Accumulating negatively avoids surprises near MAX_VALUE
- digit = Character.digit (c, 10);
- if (digit < 0) {
- throw new NumberFormatException (s);
- }
- if (result < multmin) {
- throw new NumberFormatException (s);
- }
- result *= 10;
- if (result < limit + digit) {
- throw new NumberFormatException (s);
- }
- result -= digit;
- }
- if (negative) {
- if (i > 1) {
- return result;
- }
- else { // Only got "-"
- throw new NumberFormatException (s);
- }
- }
- else {
- return -result;
- }
- }
-
- private final void skipPadding (String s, int i, int length) throws NumberFormatException
- {
- while (i < length) {
- if (s.charAt (i++) != ' ')
- throw new NumberFormatException (s);
+
+final class CrossConverters {
+ private final static java.math.BigDecimal bdMaxByteValue__ =
+ java.math.BigDecimal.valueOf(Byte.MAX_VALUE);
+ private final static java.math.BigDecimal bdMinByteValue__ =
+ java.math.BigDecimal.valueOf(Byte.MIN_VALUE);
+ private final static java.math.BigDecimal bdMaxShortValue__ =
+ java.math.BigDecimal.valueOf(Short.MAX_VALUE);
+ private final static java.math.BigDecimal bdMinShortValue__ =
+ java.math.BigDecimal.valueOf(Short.MIN_VALUE);
+ private final static java.math.BigDecimal bdMaxIntValue__ =
+ java.math.BigDecimal.valueOf(Integer.MAX_VALUE);
+ private final static java.math.BigDecimal bdMinIntValue__ =
+ java.math.BigDecimal.valueOf(Integer.MIN_VALUE);
+ private final static java.math.BigDecimal bdMaxLongValue__ =
+ java.math.BigDecimal.valueOf(Long.MAX_VALUE);
+ private final static java.math.BigDecimal bdMinLongValue__ =
+ java.math.BigDecimal.valueOf(Long.MIN_VALUE);
+ private final static java.math.BigDecimal bdMaxFloatValue__ =
+ new java.math.BigDecimal(Float.MAX_VALUE);
+ private final static java.math.BigDecimal bdMinFloatValue__ =
+ new java.math.BigDecimal(-Float.MAX_VALUE);
+ private final static java.math.BigDecimal bdMaxDoubleValue__ =
+ new java.math.BigDecimal(Double.MAX_VALUE);
+ private final static java.math.BigDecimal bdMinDoubleValue__ =
+ new java.math.BigDecimal(-Double.MAX_VALUE);
+
+ // Since BigDecimals are immutable, we can return pointers to these canned 0's and 1's.
+ private final static java.math.BigDecimal bdZero__ = java.math.BigDecimal.valueOf(0);
+ private final static java.math.BigDecimal bdOne__ = java.math.BigDecimal.valueOf(1);
+
+ // ---------------------- state ----------------------------------------------
+
+ Agent agent_;
+
+ // ----------------------constructors/finalizer-------------------------------
+
+ CrossConverters(Agent agent) {
+ agent_ = agent;
+ }
+
+ // ---------------------------------------------------------------------------
+ // The following methods are used for input cross conversion.
+ // ---------------------------------------------------------------------------
+
+ //---------------------------- setObject() methods ---------------------------
+
+ // Convert from boolean source to target type.
+ // In support of PS.setBoolean().
+ // See differences.html for DNC setBoolean() semantics.
+ final Object setObject(int targetType, boolean source) throws SqlException {
+ return setObject(targetType, (short) (source ? 1 : 0));
+ }
+
+ // Convert from byte source to target type
+ // In support of PS.setByte()
+ final Object setObject(int targetType, byte source) throws SqlException {
+ return setObject(targetType, (short) source);
+ }
+
+ // Convert from short source to target type
+ // In support of PS.setShort()
+ final Object setObject(int targetType, short source) throws SqlException {
+ switch (targetType) {
+ case Types.SMALLINT:
+ return new Short(source);
+
+ case Types.INTEGER:
+ return new Integer(source);
+
+ case Types.BIGINT:
+ return new Long(source);
+
+ case Types.REAL:
+ return new Float(source);
+
+ case Types.DOUBLE:
+ return new Double(source);
+
+ case Types.DECIMAL:
+ return java.math.BigDecimal.valueOf(source);
+
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return String.valueOf(source);
+
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // Convert from integer source to target type
+ // In support of PS.setInt()
+ final Object setObject(int targetType, int source) throws SqlException {
+ switch (targetType) {
+ case Types.SMALLINT:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source > Short.MAX_VALUE || source < Short.MIN_VALUE)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Short((short) source);
+
+ case Types.INTEGER:
+ return new Integer(source);
+
+ case Types.BIGINT:
+ return new Long(source);
+
+ case Types.REAL:
+ return new Float(source);
+
+ case Types.DOUBLE:
+ return new Double(source);
+
+ case Types.DECIMAL:
+ return java.math.BigDecimal.valueOf(source);
+
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return String.valueOf(source);
+
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // This method is used in lieu of setObject(targetType, sourceObject) because we
+ // don't support the BIT/BOOLEAN as underlying DERBY targetTypes.
+ final boolean setBooleanFromObject(Object source, int sourceType) throws SqlException {
+ switch (sourceType) {
+ case Types.SMALLINT:
+ return getBooleanFromShort(((Short) source).shortValue());
+ case Types.INTEGER:
+ return getBooleanFromInt(((Integer) source).intValue());
+ case Types.BIGINT:
+ return getBooleanFromLong(((java.math.BigInteger) source).longValue());
+ case Types.REAL:
+ return getBooleanFromFloat(((Float) source).floatValue());
+ case Types.DOUBLE:
+ return getBooleanFromDouble(((Double) source).doubleValue());
+ case Types.DECIMAL:
+ return getBooleanFromLong(((java.math.BigDecimal) source).longValue());
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return getBooleanFromString((String) source);
+ default:
+ throw new ColumnTypeConversionException(agent_.logWriter_);
+ }
+ }
+
+ // This method is used in lieu of setObject(targetType, sourceObject) because we
+ // don't support the BIT/BOOLEAN as underlying DERBY targetTypes.
+ final byte setByteFromObject(Object source, int sourceType) throws SqlException {
+ switch (sourceType) {
+ case Types.SMALLINT:
+ return getByteFromShort(((Short) source).shortValue());
+ case Types.INTEGER:
+ return getByteFromInt(((Integer) source).intValue());
+ case Types.BIGINT:
+ return getByteFromLong(((java.math.BigInteger) source).longValue());
+ case Types.REAL:
+ return getByteFromFloat(((Float) source).floatValue());
+ case Types.DOUBLE:
+ return getByteFromDouble(((Double) source).doubleValue());
+ case Types.DECIMAL:
+ return getByteFromLong(((java.math.BigDecimal) source).longValue());
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return getByteFromString((String) source);
+ default:
+ throw new ColumnTypeConversionException(agent_.logWriter_);
+ }
+ }
+
+ // Convert from long source to target type
+ // In support of PS.setLong()
+ final Object setObject(int targetType, long source) throws SqlException {
+ switch (targetType) {
+ case Types.SMALLINT:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source > Short.MAX_VALUE || source < Short.MIN_VALUE)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Short((short) source);
+
+ case Types.INTEGER:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source > Integer.MAX_VALUE || source < Integer.MIN_VALUE)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Integer((int) source);
+
+ case Types.BIGINT:
+ return new Long(source);
+
+ case Types.REAL:
+ return new Float(source);
+
+ case Types.DOUBLE:
+ return new Double(source);
+
+ case Types.DECIMAL:
+ return java.math.BigDecimal.valueOf(source);
+
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return String.valueOf(source);
+
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // Convert from floating point source to target type
+ // In support of PS.setFloat()
+ final Object setObject(int targetType, float source) throws SqlException {
+ switch (targetType) {
+ case Types.SMALLINT:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source > Short.MAX_VALUE || source < Short.MIN_VALUE)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Short((short) source);
+
+ case Types.INTEGER:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source > Integer.MAX_VALUE || source < Integer.MIN_VALUE)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Integer((int) source);
+
+ case Types.BIGINT:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source > Long.MAX_VALUE || source < Long.MIN_VALUE)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Long((long) source);
+
+ case Types.REAL:
+ if (Configuration.rangeCheckCrossConverters &&
+ // change the check from (source > Float.MAX_VALUE || source < -Float.MIN_VALUE))
+ // to the following:
+ //-----------------------------------------------------------------------------------
+ // -infinity 0 +infinity
+ // |__________________________|======|________________________|
+ // <-3.4E+38| | | |>+3.4E+38
+ // | | |_________________ |
+ // | |-1.4E-45 <X< +1.4E-45
+ // | |________________________
+ //-----------------------------------------------------------------------------------
+ (source == Float.POSITIVE_INFINITY || source == Float.NEGATIVE_INFINITY)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Float(source);
+
+ case Types.DOUBLE:
+ if (Configuration.rangeCheckCrossConverters &&
+ //-------------------------------------------------------------------------------------
+ // -infinity 0 +infinity
+ // |__________________________|======|________________________|
+ // <-1.79E+308| | | |>+1.79E+308
+ // | | |_________________ |
+ // | |-4.9E-324 <X< +4.9E-324
+ // | |________________________
+ //-------------------------------------------------------------------------------------
+ (source == Double.POSITIVE_INFINITY || source == Double.NEGATIVE_INFINITY)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ // source passed in is a float, do we need to check if the source already contains "infinity"??
+ return new Double(String.valueOf(source));
+
+ case Types.DECIMAL:
+ // Can't use the following commented out line because it changes precision of the result.
+ //return new java.math.BigDecimal (source);
+ return new java.math.BigDecimal(String.valueOf(source)); // This matches derby semantics
+
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return String.valueOf(source);
+
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // Convert from double floating point source to target type
+ // In support of PS.setDouble()
+ final Object setObject(int targetType, double source) throws SqlException {
+ switch (targetType) {
+ case Types.SMALLINT:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source > Short.MAX_VALUE || source < Short.MIN_VALUE)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Short((short) source);
+
+ case Types.INTEGER:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source > Integer.MAX_VALUE || source < Integer.MIN_VALUE)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Integer((int) source);
+
+ case Types.BIGINT:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source > Long.MAX_VALUE || source < Long.MIN_VALUE)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Long((long) source);
+
+ case Types.REAL:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source > Float.MAX_VALUE || source < -Float.MAX_VALUE)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Float((float) source);
+
+ case Types.DOUBLE:
+ if (Configuration.rangeCheckCrossConverters &&
+ // change the check from (source > Double.MAX_VALUE || source < -Double.MIN_VALUE))
+ // to the following:
+ //-------------------------------------------------------------------------------------
+ // -infinity 0 +infinity
+ // |__________________________|======|________________________|
+ // <-1.79E+308| | | |>+1.79E+308
+ // | | |_________________ |
+ // | |-4.9E-324 <X< +4.9E-324
+ // | |________________________
+ //-------------------------------------------------------------------------------------
+ (source == Double.POSITIVE_INFINITY || source == Double.NEGATIVE_INFINITY)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Double(source);
+
+ case Types.DECIMAL:
+ return new java.math.BigDecimal(String.valueOf(source)); // This matches derby semantics
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return String.valueOf(source);
+
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // Convert from big decimal source to target type
+ // In support of PS.setBigDecimal()
+ final Object setObject(int targetType, java.math.BigDecimal source) throws SqlException {
+ switch (targetType) {
+ case Types.SMALLINT:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source.compareTo(bdMaxShortValue__) == 1 || source.compareTo(bdMinShortValue__) == -1)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Short(source.shortValue());
+
+ case Types.INTEGER:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source.compareTo(bdMaxIntValue__) == 1 || source.compareTo(bdMinIntValue__) == -1)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Integer(source.intValue());
+
+ case Types.BIGINT:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source.compareTo(bdMaxLongValue__) == 1 || source.compareTo(bdMinLongValue__) == -1)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Long(source.longValue());
+
+ case Types.REAL:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source.compareTo(bdMaxFloatValue__) == 1 || source.compareTo(bdMinFloatValue__) == -1)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Float(source.floatValue());
+
+ case Types.DOUBLE:
+ if (Configuration.rangeCheckCrossConverters &&
+ (source.compareTo(bdMaxDoubleValue__) == 1 || source.compareTo(bdMinDoubleValue__) == -1)) {
+ throw new LossOfPrecisionConversionException(agent_.logWriter_, String.valueOf(source));
+ }
+ return new Double(source.doubleValue());
+
+ case Types.DECIMAL:
+ return source;
+
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return String.valueOf(source);
+
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // Convert from date source to target type
+ // In support of PS.setDate()
+ final Object setObject(int targetType, java.sql.Date source) throws SqlException {
+ switch (targetType) {
+
+ case java.sql.Types.DATE:
+ return source;
+
+ case java.sql.Types.TIMESTAMP:
+ return new java.sql.Timestamp(source.getTime());
+
+ case java.sql.Types.CHAR:
+ case java.sql.Types.VARCHAR:
+ case java.sql.Types.LONGVARCHAR:
+ return String.valueOf(source);
+
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // Convert from time source to target type
+ // In support of PS.setTime()
+ final Object setObject(int targetType, java.sql.Time source) throws SqlException {
+ switch (targetType) {
+
+ case java.sql.Types.TIME:
+ return source;
+
+ case java.sql.Types.CHAR:
+ case java.sql.Types.VARCHAR:
+ case java.sql.Types.LONGVARCHAR:
+ return String.valueOf(source);
+
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // Convert from date source to target type
+ // In support of PS.setTimestamp()
+ final Object setObject(int targetType, java.sql.Timestamp source) throws SqlException {
+ switch (targetType) {
+
+ case java.sql.Types.TIMESTAMP:
+ return source;
+
+ case java.sql.Types.TIME:
+ return new java.sql.Time(source.getTime());
+
+ case java.sql.Types.DATE:
+ return new java.sql.Date(source.getTime());
+
+ case java.sql.Types.CHAR:
+ case java.sql.Types.VARCHAR:
+ case java.sql.Types.LONGVARCHAR:
+ return String.valueOf(source);
+
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // setString() against BINARY columns cannot be implemented consistently because w/out metadata, we'll send char encoding bytes.
+ // So we refuse setString() requests altogether.
+ // Convert from string source to target type.
+ // In support of PS.setString()
+ final Object setObject(int targetDriverType, String source) throws SqlException {
+ try {
+ switch (targetDriverType) {
+ case Types.SMALLINT:
+ return Short.valueOf(source);
+
+ case Types.INTEGER:
+ return Integer.valueOf(source);
+
+ case Types.BIGINT:
+ return Long.valueOf(source);
+
+ case Types.REAL:
+ return Float.valueOf(source);
+
+ case Types.DOUBLE:
+ return Double.valueOf(source);
+
+ case Types.DECIMAL:
+ return new java.math.BigDecimal(source);
+
+ case java.sql.Types.DATE:
+ return date_valueOf(source);
+
+ case java.sql.Types.TIME:
+ return time_valueOf(source);
+
+ case java.sql.Types.TIMESTAMP:
+ return timestamp_valueOf(source);
+
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return source;
+
+ case Types.CLOB:
+ return new Clob(agent_, source);
+
+ // setString() against BINARY columns is problematic because w/out metadata, we'll send char encoding bytes.
+ // So we refuse setString() requests altogether.
+ case Types.BINARY:
+ case Types.VARBINARY:
+ case Types.LONGVARBINARY:
+ case Types.BLOB:
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ } catch (java.lang.NumberFormatException e) {
+ throw new SqlException(agent_.logWriter_,
+ e,
+ "Invalid data conversion:"
+ + " Parameter instance "
+ + source
+ + " is invalid for requested conversion.");
+ }
+ }
+
+ // -- methods in support of setObject(String)/getString() on BINARY columns---
+
+
+ // Convert from byte[] source to target type
+ // In support of PS.setBytes()
+ final Object setObject(int targetType, byte[] source) throws SqlException {
+ switch (targetType) {
+ case Types.BINARY:
+ case Types.VARBINARY:
+ case Types.LONGVARBINARY:
+ return source;
+ case Types.BLOB:
+ return new Blob(source, agent_, 0);
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // Convert from Reader source to target type
+ // In support of PS.setCharacterStream()
+ final Object setObject(int targetType, java.io.Reader source, int length) throws SqlException {
+ switch (targetType) {
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return setStringFromReader(source, length);
+ case Types.CLOB:
+ return new Clob(agent_, source, length);
+ // setCharacterStream() against BINARY columns is problematic because w/out metadata, we'll send char encoding bytes.
+ // There's no clean solution except to just not support setObject(String/Reader/Stream)
+ case Types.BINARY:
+ case Types.VARBINARY:
+ case Types.LONGVARBINARY:
+ case Types.BLOB:
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // create a String by reading all of the bytes from reader
+ private final String setStringFromReader(java.io.Reader r, int length) throws SqlException {
+ java.io.StringWriter sw = new java.io.StringWriter();
+ try {
+ int read = r.read();
+ int totalRead = 0;
+ while (read != -1) {
+ totalRead++;
+ sw.write(read);
+ read = r.read();
+ }
+ if (length != totalRead) {
+ throw new SqlException(agent_.logWriter_, "The Reader object does not contain length characters");
+ }
+ return sw.toString();
+ } catch (java.io.IOException e) {
+ throw new SqlException(agent_.logWriter_, e.getMessage());
+ }
+ }
+
+ // Convert from InputStream source to target type.
+ // In support of PS.setAsciiStream, PS.setUnicodeStream
+ // Note: PS.setCharacterStream() is handled by setObject(Reader)
+ final Object setObjectFromCharacterStream(int targetType, java.io.InputStream source, String encoding, int length) throws SqlException {
+ switch (targetType) {
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return setStringFromStream(source, encoding, length);
+ case Types.CLOB:
+ return new Clob(agent_, source, encoding, length);
+ case Types.BINARY:
+ case Types.VARBINARY:
+ case Types.LONGVARBINARY:
+ case Types.BLOB:
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+
+ // create a String by reading all of the bytes from inputStream, applying encoding
+ private final String setStringFromStream(java.io.InputStream is, String encoding, int length) throws SqlException {
+ try {
+ java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
+ int totalRead = 0;
+
+ try {
+ int read = is.read();
+ while (read != -1) {
+ totalRead++;
+ baos.write(read);
+ read = is.read();
+ }
+ } catch (java.io.IOException e) {
+ throw new SqlException(agent_.logWriter_, e.getMessage());
+ }
+
+ if (length != totalRead) {
+ throw new SqlException(agent_.logWriter_, "The InputStream object does not contain length bytes");
+ }
+
+ return new String(baos.toByteArray(), encoding);
+ } catch (java.io.UnsupportedEncodingException e) {
+ throw new SqlException(agent_.logWriter_, e.getMessage());
+ }
+ }
+
+ // Convert from Blob source to target type
+ // In support of PS.setBlob()
+ final Object setObject(int targetType, java.sql.Blob source) throws SqlException {
+ switch (targetType) {
+ case Types.BLOB:
+ return source;
+ case Types.BINARY:
+ case Types.VARBINARY:
+ case Types.LONGVARBINARY:
+ try {
+ return source.getBytes(1L, (int) source.length());
+ } catch (java.sql.SQLException e) {
+ throw new SqlException(agent_.logWriter_, e.getMessage());
+ }
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // Convert from InputStream source to target type
+ // In support of PS.setBinaryStream()
+ final Object setObjectFromBinaryStream(int targetType, java.io.InputStream source, int length) throws SqlException {
+ switch (targetType) {
+ case Types.BINARY:
+ case Types.VARBINARY:
+ case Types.LONGVARBINARY:
+ return setBytesFromStream(source, length);
+ case Types.BLOB:
+ return new Blob(agent_, source, length);
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // create a byte[] by reading all of the bytes from inputStream
+ private final byte[] setBytesFromStream(java.io.InputStream is, int length) throws SqlException {
+ java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
+ int totalRead = 0;
+
+ try {
+ int read = is.read();
+ while (read != -1) {
+ totalRead++;
+ baos.write(read);
+ read = is.read();
+ }
+
+ if (length != totalRead) {
+ throw new SqlException(agent_.logWriter_, "The InputStream object does not contain length bytes");
+ }
+ } catch (java.io.IOException e) {
+ throw new SqlException(agent_.logWriter_, e.getMessage());
+ }
+ return baos.toByteArray();
+ }
+
+ // Convert from Clob source to target type
+ // In support of PS.setClob()
+ final Object setObject(int targetType, java.sql.Clob source) throws SqlException {
+ switch (targetType) {
+ case Types.CLOB:
+ return source;
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return source.toString();
+ default:
+ throw new SqlException(agent_.logWriter_, "Illegal Conversion");
+ }
+ }
+
+ // The Java compiler uses static binding, so we can't rely on the strongly
+ // typed setObject() methods above for each of the Java Object instance types.
+ final Object setObject(int targetType, Object source) throws SqlException {
+ if (source instanceof Boolean) {
+ return setObject(targetType, ((Boolean) source).booleanValue());
+ } else if (source instanceof Integer) {
+ return setObject(targetType, ((Integer) source).intValue());
+ } else if (source instanceof Long) {
+ return setObject(targetType, ((Long) source).longValue());
+ } else if (source instanceof Float) {
+ return setObject(targetType, ((Float) source).floatValue());
+ } else if (source instanceof Double) {
+ return setObject(targetType, ((Double) source).doubleValue());
+ } else if (source instanceof java.math.BigDecimal) {
[... 864 lines stripped ...]