src/org/objectweb/cjdbc/driver/PreparedStatement.java

説明を見る。

package org.objectweb.cjdbc.driver;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.math.BigDecimal;
import java.sql.Array;
import java.sql.Date;
import java.sql.ParameterMetaData;
import java.sql.Ref;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;

import org.objectweb.cjdbc.common.sql.NotImplementedException;

public class PreparedStatement extends Statement
    implements
      java.sql.PreparedStatement
{
  public static final String BYTE_TAG        = "b|";
  public static final String BYTES_TAG       = "B|";
  public static final String BLOB_TAG        = "c|";
  public static final String CLOB_TAG        = "C|";
  public static final String BOOLEAN_TAG     = "0|";
  public static final String BIG_DECIMAL_TAG = "1|";
  public static final String DATE_TAG        = "d|";
  public static final String DOUBLE_TAG      = "D|";
  public static final String FLOAT_TAG       = "F|";
  public static final String INTEGER_TAG     = "I|";
  public static final String LONG_TAG        = "L|";
  public static final String NULL_TAG        = "N|";
  public static final String OBJECT_TAG      = "O|";
  public static final String SHORT_TAG       = "s|";
  public static final String STRING_TAG      = "S|";
  public static final String TIME_TAG        = "t|";
  public static final String TIMESTAMP_TAG   = "T|";

  protected String           sql;
  private String[]           templateStrings;
  private String[]           inStrings;

  // Some performance caches
  private StringBuffer       sbuf            = new StringBuffer();

  public PreparedStatement(Connection connection, String sqlStatement)
      throws SQLException
  {
    super(connection);

    ArrayList v = new ArrayList();
    int lastParmEnd = 0;

    // The following two boolean switches are used to make sure we're not
    // counting "?" in either strings or metadata strings. For instance the
    // following query:
    //    select '?' "A ? value" from dual
    // doesn't have any parameters.

    boolean inString = false;
    boolean inMetaString = false;

    this.sql = sqlStatement.trim();
    this.connection = connection;
    for (int i = 0; i < sql.length(); ++i)
    {
      if (sql.charAt(i) == '\'')
        inString = !inString;
      if (sql.charAt(i) == '"')
        inMetaString = !inMetaString;
      if ((sql.charAt(i) == '?') && (!(inString || inMetaString)))
      {
        v.add(sql.substring(lastParmEnd, i));
        lastParmEnd = i + 1;
      }
    }
    v.add(sql.substring(lastParmEnd, sql.length()));

    int size = v.size();
    templateStrings = new String[size];
    inStrings = new String[size - 1];
    clearParameters();

    for (int i = 0; i < size; ++i)
      templateStrings[i] = (String) v.get(i);
  }

  public void close() throws SQLException
  {
    sql = null;
    templateStrings = null;
    inStrings = null;

    super.close();
  }

  public java.sql.ResultSet executeQuery() throws SQLException
  {
    return super.executeQuery(sql, compileQuery()); // in Statement class
  }

  public int executeUpdate() throws SQLException
  {
    return super.executeUpdateWithSkeleton(sql, compileQuery());
    // in Statement class
  }

  protected synchronized String compileQuery() throws SQLException
  {
    sbuf.setLength(0);
    int i;

    for (i = 0; i < inStrings.length; ++i)
    {
      if (inStrings[i] == null)
        throw new SQLException("Parameter " + (i + 1) + " is incorrect");
      sbuf.append(templateStrings[i]).append(inStrings[i]);
    }
    sbuf.append(templateStrings[inStrings.length]);
    return sbuf.toString();
  }

  protected String doEscapeProcessing(String x)
  {
    // use the shared buffer object. Should never clash but this
    // makes us thread safe!
    synchronized (sbuf)
    {
      sbuf.setLength(0);
      int i;
      sbuf.append(connection.getEscapeChar());
      for (i = 0; i < x.length(); ++i)
      {
        char c = x.charAt(i);
        if ((c == '\'' && connection.isEscapeSingleQuote())
            || (c == '\\' && connection.isEscapeBackslash()))
          sbuf.append("" + c);
        sbuf.append(c);
      }
      sbuf.append(connection.getEscapeChar());
    }
    return sbuf.toString();
  }

  public void setNull(int parameterIndex, int sqlType) throws SQLException
  {
    if (connection.isDriverProcessed())
      set(parameterIndex, "null");
    else
      set(parameterIndex, Connection.startParamTag + NULL_TAG + sqlType
          + Connection.endParamTag);
  }

  public void setBoolean(int parameterIndex, boolean x) throws SQLException
  {
    if (connection.isDriverProcessed())
    {
      set(parameterIndex, x
          ? connection.getPreparedStatementBooleanTrue()
          : connection.getPreparedStatementBooleanFalse());
    }
    else
    {
      set(parameterIndex, Connection.startParamTag + BOOLEAN_TAG + x
          + Connection.endParamTag);
    }
  }

  public void setByte(int parameterIndex, byte x) throws SQLException
  {
    if (connection.isDriverProcessed())
    {
      set(parameterIndex, Integer.toString(x));
    }
    else
    {
      set(parameterIndex, Connection.startParamTag + BYTE_TAG
          + Integer.toString(x) + Connection.endParamTag);
    }
  }

  public void setShort(int parameterIndex, short x) throws SQLException
  {
    if (connection.isDriverProcessed())
    {
      set(parameterIndex, Integer.toString(x));
    }
    else
    {
      set(parameterIndex, Connection.startParamTag + SHORT_TAG
          + Integer.toString(x) + Connection.endParamTag);
    }
  }

  public void setInt(int parameterIndex, int x) throws SQLException
  {
    if (connection.isDriverProcessed())
    {
      set(parameterIndex, Integer.toString(x));
    }
    else
    {
      set(parameterIndex, Connection.startParamTag + INTEGER_TAG
          + Integer.toString(x) + Connection.endParamTag);
    }
  }

  public void setLong(int parameterIndex, long x) throws SQLException
  {
    if (connection.isDriverProcessed())
    {
      set(parameterIndex, Long.toString(x));
    }
    else
    {
      set(parameterIndex, Connection.startParamTag + LONG_TAG
          + Long.toString(x) + Connection.endParamTag);
    }
  }

  public void setFloat(int parameterIndex, float x) throws SQLException
  {
    if (connection.isDriverProcessed())
    {
      set(parameterIndex, Float.toString(x));
    }
    else
    {
      set(parameterIndex, Connection.startParamTag + FLOAT_TAG
          + Float.toString(x) + Connection.endParamTag);
    }
  }

  public void setDouble(int parameterIndex, double x) throws SQLException
  {
    if (connection.isDriverProcessed())
    {
      set(parameterIndex, Double.toString(x));
    }
    else
    {
      set(parameterIndex, Connection.startParamTag + DOUBLE_TAG
          + Double.toString(x) + Connection.endParamTag);
    }
  }

  public void setBigDecimal(int parameterIndex, BigDecimal x)
      throws SQLException
  {
    if (connection.isDriverProcessed())
    {
      if (x == null)
        setNull(parameterIndex, Types.DECIMAL);
      else
        set(parameterIndex, x.toString());
    }
    else
    {
      if (x == null)
        set(parameterIndex, Connection.startParamTag + BIG_DECIMAL_TAG + "null"
            + Connection.endParamTag);
      else
        set(parameterIndex, Connection.startParamTag + BIG_DECIMAL_TAG
            + x.toString() + Connection.endParamTag);
    }
  }

  public void setString(int parameterIndex, String x) throws SQLException
  {
    if (connection.isDriverProcessed())
    {
      if (x == null)
        // if the passed string is null, then set this column to null
        setNull(parameterIndex, Types.VARCHAR);
      else
      {
        if (escapeProcessing
            && (connection.isEscapeBackslash() || connection
                .isEscapeSingleQuote()))
          set(parameterIndex, doEscapeProcessing(x));
        else
          // No escape processing
          set(parameterIndex, x);
      }
    }
    else
    {
      if (x == null)
        set(parameterIndex, Connection.startParamTag + STRING_TAG + "null"
            + Connection.endParamTag);
      else
        // No escape processing is needed for queries not being parsed into
        // statements.
        set(parameterIndex, Connection.startParamTag + STRING_TAG + x
            + Connection.endParamTag);
    }
  }

  public void setBytes(int parameterIndex, byte x[]) throws SQLException
  {
    String blob;
    try
    {
      synchronized (sbuf)
      {
        if (connection.isDriverProcessed())
        {
          blob = connection.getBlobFilter().encode(x);
          sbuf.setLength(0);
          sbuf.append(connection.escapeChar);
          sbuf.append(blob);
          sbuf.append(connection.escapeChar);
          set(parameterIndex, sbuf.toString());
        }
        else
        {
          sbuf.setLength(0);
          sbuf.append(x);
          set(parameterIndex, Connection.startParamTag + BYTES_TAG
              + sbuf.toString() + Connection.endParamTag);
        }
      }
    }
    catch (OutOfMemoryError oome)
    {
      blob = null;
      sbuf = null;
      System.gc();
      throw new SQLException("Out of memory");
    }
  }

  public void setDate(int parameterIndex, java.sql.Date x) throws SQLException
  {
    if (connection.isDriverProcessed())
    {
      if (x == null)
        setNull(parameterIndex, Types.DATE);
      else
        set(parameterIndex, "'" + new java.sql.Date(x.getTime()).toString()
            + "'");
    }
    else
    {
      if (x == null)
        set(parameterIndex, Connection.startParamTag + DATE_TAG + "null"
            + Connection.endParamTag);
      else
        set(parameterIndex, Connection.startParamTag + DATE_TAG
            + new java.sql.Date(x.getTime()).toString()
            + Connection.endParamTag);
    }
  }

  public void setTime(int parameterIndex, Time x) throws SQLException
  {
    if (connection.isDriverProcessed())
    {
      if (x == null)
        setNull(parameterIndex, Types.TIME);
      else
        set(parameterIndex, "{t '" + x.toString() + "'}");
    }
    else
    {
      if (x == null)
        set(parameterIndex, Connection.startParamTag + TIME_TAG + "null"
            + Connection.endParamTag);
      else
        set(parameterIndex, Connection.startParamTag + TIME_TAG + x.toString()
            + Connection.endParamTag);
    }
  }

  public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException
  {
    if (connection.isDriverProcessed())
    {
      if (x == null)
        setNull(parameterIndex, Types.TIMESTAMP);
      else
      {
        // Be careful don't use instanceof here since it would match derived
        // classes.
        if (x.getClass().equals(Timestamp.class))
          set(parameterIndex, "'" + x.toString() + "'");
        else
          set(parameterIndex, "'" + new Timestamp(x.getTime()).toString() + "'");
      }
    }
    else
    {
      if (x == null)
        set(parameterIndex, Connection.startParamTag + TIMESTAMP_TAG + "null"
            + Connection.endParamTag);
      else
      {
        if (x.getClass().equals(Timestamp.class))
          set(parameterIndex, Connection.startParamTag + TIMESTAMP_TAG
              + x.toString() + Connection.endParamTag);
        else
          set(parameterIndex, Connection.startParamTag + TIMESTAMP_TAG
              + new Timestamp(x.getTime()).toString() + Connection.endParamTag);
      }
    }
  }

  public void setAsciiStream(int parameterIndex, InputStream x, int length)
      throws SQLException
  {
    setBinaryStream(parameterIndex, x, length);
  }

  public void setUnicodeStream(int parameterIndex, InputStream x, int length)
      throws SQLException
  {
    setBinaryStream(parameterIndex, x, length);
  }

  public void setBinaryStream(int parameterIndex, InputStream x, int length)
      throws SQLException
  {
    byte[] data = new byte[length];
    try
    {
      x.read(data, 0, length);
    }
    catch (Exception ioe)
    {
      throw new SQLException("Problem with streaming of data");
    }
    setBytes(parameterIndex, data);
  }

  public void clearParameters() throws SQLException
  {
    int i;

    for (i = 0; i < inStrings.length; i++)
      inStrings[i] = null;
  }

  public void setObject(int parameterIndex, Object x, int targetSqlType,
      int scale) throws SQLException
  {
    if (x == null)
    {
      setNull(parameterIndex, targetSqlType);
    }
    else
    {
      switch (targetSqlType)
      {
        case Types.TINYINT :
        case Types.SMALLINT :
        case Types.INTEGER :
        case Types.BIGINT :
        case Types.REAL :
        case Types.FLOAT :
        case Types.DOUBLE :
        case Types.DECIMAL :
        case Types.NUMERIC :
          // Cast to Number is not necessary
          set(parameterIndex, x.toString());
          break;
        case Types.BIT :
        case Types.BOOLEAN :
          setBoolean(parameterIndex, ((Boolean) x).booleanValue());
          break;
        case Types.CHAR :
        case Types.VARCHAR :
        case Types.LONGVARCHAR :
          setString(parameterIndex, (String) x);
          break;
        case Types.BINARY :
        case Types.VARBINARY :
        case Types.LONGVARBINARY :
          setBytes(parameterIndex, (byte[]) x);
          break;
        case Types.DATE :
          setDate(parameterIndex, (java.sql.Date) x);
          break;
        case Types.TIME :
          setTime(parameterIndex, (Time) x);
          break;
        case Types.TIMESTAMP :
          setTimestamp(parameterIndex, (Timestamp) x);
          break;
        case Types.BLOB :
          setBlob(parameterIndex, (Blob) x);
          break;
        case Types.DATALINK :
          setURL(parameterIndex, (java.net.URL) x);
          break;
        case Types.JAVA_OBJECT :
        case Types.OTHER :
          setObject(parameterIndex, x);
          break;
        default :
          throw new SQLException("Unsupported type value");
      }
    }
  }

  public void setObject(int parameterIndex, Object x, int targetSqlType)
      throws SQLException
  {
    setObject(parameterIndex, x, targetSqlType, 0);
  }

  public void setObject(int parameterIndex, Object x) throws SQLException
  {
    if (x == null)
    {
      if (connection.isDriverProcessed())
        setNull(parameterIndex, Types.JAVA_OBJECT);
      else
        set(parameterIndex, Connection.startParamTag + OBJECT_TAG + "null"
            + Connection.endParamTag);
    }
    else
    {
      if (x instanceof String)
        setString(parameterIndex, (String) x);
      else if (x instanceof BigDecimal)
        setBigDecimal(parameterIndex, (BigDecimal) x);
      else if (x instanceof Short)
        setShort(parameterIndex, ((Short) x).shortValue());
      else if (x instanceof Integer)
        setInt(parameterIndex, ((Integer) x).intValue());
      else if (x instanceof Long)
        setLong(parameterIndex, ((Long) x).longValue());
      else if (x instanceof Float)
        setFloat(parameterIndex, ((Float) x).floatValue());
      else if (x instanceof Double)
        setDouble(parameterIndex, ((Double) x).doubleValue());
      else if (x instanceof byte[])
        setBytes(parameterIndex, (byte[]) x);
      else if (x instanceof java.sql.Date)
        setDate(parameterIndex, (java.sql.Date) x);
      else if (x instanceof Time)
        setTime(parameterIndex, (Time) x);
      else if (x instanceof Timestamp)
        setTimestamp(parameterIndex, (Timestamp) x);
      else if (x instanceof Boolean)
        setBoolean(parameterIndex, ((Boolean) x).booleanValue());
      else if (x instanceof Blob)
        setBlob(parameterIndex, (Blob) x);
      else if (x instanceof java.net.URL)
        setURL(parameterIndex, (java.net.URL) x);
      else if (x instanceof Serializable)
      {
        ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
        try
        {
          // Serialize object to byte array
          ObjectOutputStream objectOutputStream = new ObjectOutputStream(
              byteOutputStream);
          objectOutputStream.writeObject(x);
          objectOutputStream.flush();
          objectOutputStream.close();
          if (connection.isDriverProcessed())
            setBytes(parameterIndex, byteOutputStream.toByteArray());
          else
            synchronized (sbuf)
            {
              sbuf.setLength(0);
              sbuf.append(byteOutputStream);
              set(parameterIndex, Connection.startParamTag + OBJECT_TAG
                  + sbuf.toString() + Connection.endParamTag);
            }
        }
        catch (IOException e)
        {
          throw new SQLException("Failed to serialize object: " + e);
        }
      }
      else
        throw new SQLException("Objects of type " + x.getClass()
            + " are not supported.");
    }
  }

  public boolean execute() throws SQLException
  {
    return super.execute(compileQuery()); // in Statement class
  }

  public String toString()
  {
    synchronized (sbuf)
    {
      sbuf.setLength(0);
      int i;

      for (i = 0; i < inStrings.length; ++i)
      {
        if (inStrings[i] == null)
          sbuf.append('?');
        else
          sbuf.append(templateStrings[i]);
        sbuf.append(inStrings[i]);
      }
      sbuf.append(templateStrings[inStrings.length]);
      return sbuf.toString();
    }
  }

  // ** JDBC 2 Extensions **

  public void addBatch() throws SQLException
  {
    super.addBatch(compileQuery());
  }

  public java.sql.ResultSetMetaData getMetaData() throws SQLException
  {
    java.sql.ResultSet rs = getResultSet();
    if (rs != null)
      return rs.getMetaData();

    // Does anyone really know what this method does?
    return null;
  }

  public void setArray(int i, Array x) throws SQLException
  {
    throw new NotImplementedException("setArray()");
  }

  public void setBlob(int i, java.sql.Blob x) throws SQLException
  {
    if (x == null)
    {
      if (connection.isDriverProcessed())
        setNull(i, Types.BLOB);
      else
        set(i, Connection.startParamTag + BLOB_TAG + "null"
            + Connection.endParamTag);
      return;
    }

    if (connection.isDriverProcessed())
      setBinaryStream(i, x.getBinaryStream(), (int) x.length());
    else
    {
      byte[] data = new byte[(int) x.length()];
      InputStream binStream = x.getBinaryStream();
      try
      {
        binStream.read(data, 0, (int) x.length());
      }
      catch (Exception ioe)
      {
        throw new SQLException("Problem with data streaming");
      }
      try
      {
        synchronized (sbuf)
        {
          sbuf.setLength(0);
          sbuf.append(x);
          set(i, Connection.startParamTag + BLOB_TAG + sbuf.toString()
              + Connection.endParamTag);
        }
      }
      catch (OutOfMemoryError oome)
      {
        sbuf = null;
        System.gc();
        throw new SQLException("Out of memory");
      }

    }
  }

  public void setCharacterStream(int i, java.io.Reader x, int length)
      throws SQLException
  {
    char[] data = new char[length];
    try
    {
      x.read(data, 0, length);
    }
    catch (Exception ioe)
    {
      throw new SQLException("Problem with streaming of data");
    }
    setString(i, new String(data));
  }

  public void setClob(int i, java.sql.Clob x) throws SQLException
  {
    if (x == null)
    {
      if (connection.isDriverProcessed())
        setNull(i, Types.CLOB);
      else
        set(i, Connection.startParamTag + CLOB_TAG + "null"
            + Connection.endParamTag);
      return;
    }
    if (connection.isDriverProcessed())
      setString(i, x.getSubString(0, (int) x.length()));
    else
      set(i, Connection.startParamTag + CLOB_TAG
          + x.getSubString(0, (int) x.length()) + Connection.endParamTag);
  }

  public void setNull(int i, int t, String s) throws SQLException
  {
    setNull(i, t);
  }

  public void setRef(int i, Ref x) throws SQLException
  {
    throw new NotImplementedException("setRef()");
  }

  public void setDate(int i, java.sql.Date d, java.util.Calendar cal)
      throws SQLException
  {
    if (d == null)
    {
      if (connection.isDriverProcessed())
        setNull(i, Types.DATE);
      else
        set(i, Connection.startParamTag + DATE_TAG + "null"
            + Connection.endParamTag);
      return;
    }
    else
    {
      if (cal == null)
        setDate(i, d);
      else
      {
        cal.setTime(d);
        setDate(i, new java.sql.Date(cal.getTime().getTime()));
      }
    }
  }

  public void setTime(int i, Time t, java.util.Calendar cal)
      throws SQLException
  {
    if (t == null)
    {
      if (connection.isDriverProcessed())
        setNull(i, Types.TIME);
      else
        set(i, Connection.startParamTag + TIME_TAG + "null"
            + Connection.endParamTag);
      return;
    }
    else
    {
      if (cal == null)
        setTime(i, t);
      else
      {
        cal.setTime(t);
        setTime(i, new java.sql.Time(cal.getTime().getTime()));
      }
    }
  }

  public void setTimestamp(int i, Timestamp t, java.util.Calendar cal)
      throws SQLException
  {
    if (t == null)
    {
      if (connection.isDriverProcessed())
        setNull(i, Types.TIMESTAMP);
      else
        set(i, Connection.startParamTag + TIMESTAMP_TAG + "null"
            + Connection.endParamTag);
      return;
    }
    else
    {
      if (cal == null)
        setTimestamp(i, t);
      else
      {
        cal.setTime(t);
        setTimestamp(i, new java.sql.Timestamp(cal.getTime().getTime()));
      }
    }
  }

  //------------------------- JDBC 3.0 -----------------------------------

  public void setURL(int parameterIndex, java.net.URL x) throws SQLException
  {
    throw new NotImplementedException("setURL");
  }

  public ParameterMetaData getParameterMetaData() throws SQLException
  {
    throw new NotImplementedException("getParameterMetaData");
  }

  // **************************************************************
  //     END OF PUBLIC INTERFACE
  // **************************************************************

  private void set(int paramIndex, String s) throws SQLException
  {
    if (paramIndex < 1 || paramIndex > inStrings.length)
      throw new SQLException("Parameter index out of range.");
    inStrings[paramIndex - 1] = s;
  }

  protected void setGeneratedKeysFlag(int autoGeneratedKeys)
  {
    generatedKeysFlag = autoGeneratedKeys;
  }

  public static void setPreparedStatement(String sql,
      java.sql.PreparedStatement ps) throws SQLException
  {
    int i = 0;
    int currentParameter = 0;

    // Set all parameters
    while ((i = sql.indexOf(Connection.startParamTag, i)) > -1)
    {
      currentParameter++;

      int typeStart = i + Connection.startParamTag.length();

      // Here we assume that all tags have the same length as the boolean tag.
      String tag = sql.substring(typeStart, typeStart + BOOLEAN_TAG.length());
      String value = sql.substring(typeStart + BOOLEAN_TAG.length(), sql
          .indexOf(Connection.endParamTag, i));

      // Test tags in alphabetical order (to make the code easier to read)
      if (tag.equals(BIG_DECIMAL_TAG))
      {
        if (value.equals("null"))
          ps.setBigDecimal(currentParameter, null);
        else
        {
          BigDecimal t = new BigDecimal(value);
          ps.setBigDecimal(currentParameter, t);
        }
      }
      else if (tag.equals(BOOLEAN_TAG))
        ps.setBoolean(currentParameter, Boolean.valueOf(value).booleanValue());
      else if (tag.equals(BYTE_TAG))
      {
        byte t = new Integer(value).byteValue();
        ps.setByte(currentParameter, t);
      }
      else if (tag.equals(BYTES_TAG))
      {
        byte[] t = value.getBytes();
        ps.setBytes(currentParameter, t);
      }
      else if (tag.equals(BLOB_TAG))
      {
        if (value.equals("null"))
          ps.setBlob(currentParameter, null);
        else
        {
          Blob b = new Blob(value.getBytes());
          ps.setBlob(currentParameter, b);
        }
      }
      else if (tag.equals(CLOB_TAG))
      {
        if (value.equals("null"))
          ps.setClob(currentParameter, null);
        else
        {
          Clob c = new Clob(value);
          ps.setClob(currentParameter, c);
        }
      }
      else if (tag.equals(DATE_TAG))
      {
        if (value.equals("null"))
          ps.setDate(currentParameter, null);
        else
          try
          {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date t = new Date(sdf.parse(value).getTime());
            ps.setDate(currentParameter, t);
          }
          catch (ParseException p)
          {
            ps.setDate(currentParameter, null);
            throw new SQLException("Couldn't format date!!!");
          }
      }
      else if (tag.equals(DOUBLE_TAG))
        ps.setDouble(currentParameter, Double.valueOf(value).doubleValue());
      else if (tag.equals(FLOAT_TAG))
        ps.setFloat(currentParameter, Float.valueOf(value).floatValue());
      else if (tag.equals(INTEGER_TAG))
        ps.setInt(currentParameter, Integer.valueOf(value).intValue());
      else if (tag.equals(LONG_TAG))
        ps.setLong(currentParameter, Long.valueOf(value).longValue());
      else if (tag.equals(NULL_TAG))
        ps.setNull(currentParameter, Integer.valueOf(value).intValue());
      else if (tag.equals(OBJECT_TAG))
      {
        if (value.equals("null"))
          ps.setObject(currentParameter, null);
        else
        {
          try
          {
            ObjectInputStream in = new ObjectInputStream(
                new ByteArrayInputStream(value.getBytes()));
            ps.setObject(currentParameter, in.readObject());
            in.close();
          }
          catch (Exception e)
          {
            throw new SQLException("Failed to rebuild object from stream " + e);
          }
        }
      }
      else if (tag.equals(SHORT_TAG))
      {
        short t = new Integer(value).shortValue();
        ps.setShort(currentParameter, t);
      }
      else if (tag.equals(STRING_TAG))
      {
        if (value.equals("null"))
          ps.setString(currentParameter, null);
        else
          ps.setString(currentParameter, value);
      }
      else if (tag.equals(TIME_TAG))
      {
        if (value.equals("null"))
          ps.setTime(currentParameter, null);
        else
          try
          {
            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
            Time t = new Time(sdf.parse(value).getTime());
            ps.setTime(currentParameter, t);
          }
          catch (ParseException p)
          {
            ps.setTime(currentParameter, null);
            throw new SQLException("Couldn't format time!!!");
          }
      }
      else if (tag.equals(TIMESTAMP_TAG))
      {
        if (value.equals("null"))
          ps.setTimestamp(currentParameter, null);
        else
          try
          {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S");
            Timestamp t = new Timestamp(sdf.parse(value).getTime());
            ps.setTimestamp(currentParameter, t);
          }
          catch (ParseException p)
          {
            ps.setTimestamp(currentParameter, null);
            throw new SQLException("Couldn't format timestamp!!!");
          }
      }
      i = typeStart;
    }
  }

}

---