开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 数据库编程 > 查看源码
PreparedStatementWrapper.java
资源名称：bookshop.zip　[点击查看]
上传用户：sxlinghang
上传日期：2022-07-20
资源大小：1405k
文件大小：25k
源码类别：

数据库编程

开发平台：

Java

PreparedStatementWrapper.java：源码内容
  1. /*
  2.    Copyright (C) 2004 MySQL AB
  4.       This program is free software; you can redistribute it and/or modify
  5.       it under the terms of the GNU General Public License as published by
  6.       the Free Software Foundation; either version 2 of the License, or
  7.       (at your option) any later version.
  9.       This program is distributed in the hope that it will be useful,
  10.       but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.       GNU General Public License for more details.
  14.       You should have received a copy of the GNU General Public License
  15.       along with this program; if not, write to the Free Software
  16.       Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  */
  19. package com.mysql.jdbc.jdbc2.optional;
  21. import com.mysql.jdbc.SQLError;
  23. import java.io.InputStream;
  24. import java.io.Reader;
  26. import java.math.BigDecimal;
  28. import java.net.URL;
  30. import java.sql.Array;
  31. import java.sql.Blob;
  32. import java.sql.Clob;
  33. import java.sql.Date;
  34. import java.sql.ParameterMetaData;
  35. import java.sql.PreparedStatement;
  36. import java.sql.Ref;
  37. import java.sql.ResultSet;
  38. import java.sql.ResultSetMetaData;
  39. import java.sql.SQLException;
  40. import java.sql.Time;
  41. import java.sql.Timestamp;
  43. import java.util.Calendar;
  46. /**
  47.  * Wraps prepared statements so that errors can be reported correctly to 
  48.  * ConnectionEventListeners.
  49.  *
  50.  * @author Mark Matthews
  51.  * 
  52.  * @version $Id: PreparedStatementWrapper.java,v 1.1.2.1 2004/02/13 17:55:30 mmatthew Exp $
  53.  */
  54. class PreparedStatementWrapper extends StatementWrapper
  55.     implements PreparedStatement {
  56.     PreparedStatementWrapper(MysqlPooledConnection conn,
  57.         PreparedStatement toWrap) {
  58.         super(conn, toWrap);
  59.     }
  61.     /* (non-Javadoc)
  62.      * @see java.sql.PreparedStatement#setArray(int, java.sql.Array)
  63.      */
  64.     public void setArray(int parameterIndex, Array x) throws SQLException {
  65.         try {
  66.             if (this.wrappedStmt != null) {
  67.                 ((PreparedStatement) this.wrappedStmt).setArray(parameterIndex,
  68.                     x);
  69.             } else {
  70.                 throw new SQLException("No operations allowed after statement closed",
  71.                     SQLError.SQL_STATE_GENERAL_ERROR);
  72.             }
  73.         } catch (SQLException sqlEx) {
  74.             checkAndFireConnectionError(sqlEx);
  75.         }
  76.     }
  78.     /* (non-Javadoc)
  79.      * @see java.sql.PreparedStatement#setAsciiStream(int, java.io.InputStream, int)
  80.      */
  81.     public void setAsciiStream(int parameterIndex, InputStream x, int length)
  82.         throws SQLException {
  83.         try {
  84.             if (this.wrappedStmt != null) {
  85.                 ((PreparedStatement) this.wrappedStmt).setAsciiStream(parameterIndex,
  86.                     x, length);
  87.             } else {
  88.                 throw new SQLException("No operations allowed after statement closed",
  89.                     SQLError.SQL_STATE_GENERAL_ERROR);
  90.             }
  91.         } catch (SQLException sqlEx) {
  92.             checkAndFireConnectionError(sqlEx);
  93.         }
  94.     }
  96.     /* (non-Javadoc)
  97.      * @see java.sql.PreparedStatement#setBigDecimal(int, java.math.BigDecimal)
  98.      */
  99.     public void setBigDecimal(int parameterIndex, BigDecimal x)
  100.         throws SQLException {
  101.         try {
  102.             if (this.wrappedStmt != null) {
  103.                 ((PreparedStatement) this.wrappedStmt).setBigDecimal(parameterIndex,
  104.                     x);
  105.             } else {
  106.                 throw new SQLException("No operations allowed after statement closed",
  107.                     SQLError.SQL_STATE_GENERAL_ERROR);
  108.             }
  109.         } catch (SQLException sqlEx) {
  110.             checkAndFireConnectionError(sqlEx);
  111.         }
  112.     }
  114.     /* (non-Javadoc)
  115.      * @see java.sql.PreparedStatement#setBinaryStream(int, java.io.InputStream, int)
  116.      */
  117.     public void setBinaryStream(int parameterIndex, InputStream x, int length)
  118.         throws SQLException {
  119.         try {
  120.             if (this.wrappedStmt != null) {
  121.                 ((PreparedStatement) this.wrappedStmt).setBinaryStream(parameterIndex,
  122.                     x, length);
  123.             } else {
  124.                 throw new SQLException("No operations allowed after statement closed",
  125.                     SQLError.SQL_STATE_GENERAL_ERROR);
  126.             }
  127.         } catch (SQLException sqlEx) {
  128.             checkAndFireConnectionError(sqlEx);
  129.         }
  130.     }
  132.     /* (non-Javadoc)
  133.      * @see java.sql.PreparedStatement#setBlob(int, java.sql.Blob)
  134.      */
  135.     public void setBlob(int parameterIndex, Blob x) throws SQLException {
  136.         try {
  137.             if (this.wrappedStmt != null) {
  138.                 ((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex, x);
  139.             } else {
  140.                 throw new SQLException("No operations allowed after statement closed",
  141.                     SQLError.SQL_STATE_GENERAL_ERROR);
  142.             }
  143.         } catch (SQLException sqlEx) {
  144.             checkAndFireConnectionError(sqlEx);
  145.         }
  146.     }
  148.     /* (non-Javadoc)
  149.      * @see java.sql.PreparedStatement#setBoolean(int, boolean)
  150.      */
  151.     public void setBoolean(int parameterIndex, boolean x)
  152.         throws SQLException {
  153.         try {
  154.             if (this.wrappedStmt != null) {
  155.                 ((PreparedStatement) this.wrappedStmt).setBoolean(parameterIndex,
  156.                     x);
  157.             } else {
  158.                 throw new SQLException("No operations allowed after statement closed",
  159.                     SQLError.SQL_STATE_GENERAL_ERROR);
  160.             }
  161.         } catch (SQLException sqlEx) {
  162.             checkAndFireConnectionError(sqlEx);
  163.         }
  164.     }
  166.     /* (non-Javadoc)
  167.      * @see java.sql.PreparedStatement#setByte(int, byte)
  168.      */
  169.     public void setByte(int parameterIndex, byte x) throws SQLException {
  170.         try {
  171.             if (this.wrappedStmt != null) {
  172.                 ((PreparedStatement) this.wrappedStmt).setByte(parameterIndex, x);
  173.             } else {
  174.                 throw new SQLException("No operations allowed after statement closed",
  175.                     SQLError.SQL_STATE_GENERAL_ERROR);
  176.             }
  177.         } catch (SQLException sqlEx) {
  178.             checkAndFireConnectionError(sqlEx);
  179.         }
  180.     }
  182.     /* (non-Javadoc)
  183.      * @see java.sql.PreparedStatement#setBytes(int, byte[])
  184.      */
  185.     public void setBytes(int parameterIndex, byte[] x)
  186.         throws SQLException {
  187.         try {
  188.             if (this.wrappedStmt != null) {
  189.                 ((PreparedStatement) this.wrappedStmt).setBytes(parameterIndex,
  190.                     x);
  191.             } else {
  192.                 throw new SQLException("No operations allowed after statement closed",
  193.                     SQLError.SQL_STATE_GENERAL_ERROR);
  194.             }
  195.         } catch (SQLException sqlEx) {
  196.             checkAndFireConnectionError(sqlEx);
  197.         }
  198.     }
  200.     /* (non-Javadoc)
  201.      * @see java.sql.PreparedStatement#setCharacterStream(int, java.io.Reader, int)
  202.      */
  203.     public void setCharacterStream(int parameterIndex, Reader reader, int length)
  204.         throws SQLException {
  205.         try {
  206.             if (this.wrappedStmt != null) {
  207.                 ((PreparedStatement) this.wrappedStmt).setCharacterStream(parameterIndex,
  208.                     reader, length);
  209.             } else {
  210.                 throw new SQLException("No operations allowed after statement closed",
  211.                     SQLError.SQL_STATE_GENERAL_ERROR);
  212.             }
  213.         } catch (SQLException sqlEx) {
  214.             checkAndFireConnectionError(sqlEx);
  215.         }
  216.     }
  218.     /* (non-Javadoc)
  219.      * @see java.sql.PreparedStatement#setClob(int, java.sql.Clob)
  220.      */
  221.     public void setClob(int parameterIndex, Clob x) throws SQLException {
  222.         try {
  223.             if (this.wrappedStmt != null) {
  224.                 ((PreparedStatement) this.wrappedStmt).setClob(parameterIndex, x);
  225.             } else {
  226.                 throw new SQLException("No operations allowed after statement closed",
  227.                     SQLError.SQL_STATE_GENERAL_ERROR);
  228.             }
  229.         } catch (SQLException sqlEx) {
  230.             checkAndFireConnectionError(sqlEx);
  231.         }
  232.     }
  234.     /* (non-Javadoc)
  235.      * @see java.sql.PreparedStatement#setDate(int, java.sql.Date)
  236.      */
  237.     public void setDate(int parameterIndex, Date x) throws SQLException {
  238.         try {
  239.             if (this.wrappedStmt != null) {
  240.                 ((PreparedStatement) this.wrappedStmt).setDate(parameterIndex, x);
  241.             } else {
  242.                 throw new SQLException("No operations allowed after statement closed",
  243.                     SQLError.SQL_STATE_GENERAL_ERROR);
  244.             }
  245.         } catch (SQLException sqlEx) {
  246.             checkAndFireConnectionError(sqlEx);
  247.         }
  248.     }
  250.     /* (non-Javadoc)
  251.      * @see java.sql.PreparedStatement#setDate(int, java.sql.Date, java.util.Calendar)
  252.      */
  253.     public void setDate(int parameterIndex, Date x, Calendar cal)
  254.         throws SQLException {
  255.         try {
  256.             if (this.wrappedStmt != null) {
  257.                 ((PreparedStatement) this.wrappedStmt).setDate(parameterIndex,
  258.                     x, cal);
  259.             } else {
  260.                 throw new SQLException("No operations allowed after statement closed",
  261.                     SQLError.SQL_STATE_GENERAL_ERROR);
  262.             }
  263.         } catch (SQLException sqlEx) {
  264.             checkAndFireConnectionError(sqlEx);
  265.         }
  266.     }
  268.     /* (non-Javadoc)
  269.      * @see java.sql.PreparedStatement#setDouble(int, double)
  270.      */
  271.     public void setDouble(int parameterIndex, double x)
  272.         throws SQLException {
  273.         try {
  274.             if (this.wrappedStmt != null) {
  275.                 ((PreparedStatement) this.wrappedStmt).setDouble(parameterIndex,
  276.                     x);
  277.             } else {
  278.                 throw new SQLException("No operations allowed after statement closed",
  279.                     SQLError.SQL_STATE_GENERAL_ERROR);
  280.             }
  281.         } catch (SQLException sqlEx) {
  282.             checkAndFireConnectionError(sqlEx);
  283.         }
  284.     }
  286.     /* (non-Javadoc)
  287.      * @see java.sql.PreparedStatement#setFloat(int, float)
  288.      */
  289.     public void setFloat(int parameterIndex, float x) throws SQLException {
  290.         try {
  291.             if (this.wrappedStmt != null) {
  292.                 ((PreparedStatement) this.wrappedStmt).setFloat(parameterIndex,
  293.                     x);
  294.             } else {
  295.                 throw new SQLException("No operations allowed after statement closed",
  296.                     SQLError.SQL_STATE_GENERAL_ERROR);
  297.             }
  298.         } catch (SQLException sqlEx) {
  299.             checkAndFireConnectionError(sqlEx);
  300.         }
  301.     }
  303.     /* (non-Javadoc)
  304.      * @see java.sql.PreparedStatement#setInt(int, int)
  305.      */
  306.     public void setInt(int parameterIndex, int x) throws SQLException {
  307.         try {
  308.             if (this.wrappedStmt != null) {
  309.                 ((PreparedStatement) this.wrappedStmt).setInt(parameterIndex, x);
  310.             } else {
  311.                 throw new SQLException("No operations allowed after statement closed",
  312.                     SQLError.SQL_STATE_GENERAL_ERROR);
  313.             }
  314.         } catch (SQLException sqlEx) {
  315.             checkAndFireConnectionError(sqlEx);
  316.         }
  317.     }
  319.     /* (non-Javadoc)
  320.      * @see java.sql.PreparedStatement#setLong(int, long)
  321.      */
  322.     public void setLong(int parameterIndex, long x) throws SQLException {
  323.         try {
  324.             if (this.wrappedStmt != null) {
  325.                 ((PreparedStatement) this.wrappedStmt).setLong(parameterIndex, x);
  326.             } else {
  327.                 throw new SQLException("No operations allowed after statement closed",
  328.                     SQLError.SQL_STATE_GENERAL_ERROR);
  329.             }
  330.         } catch (SQLException sqlEx) {
  331.             checkAndFireConnectionError(sqlEx);
  332.         }
  333.     }
  335.     /* (non-Javadoc)
  336.      * @see java.sql.PreparedStatement#getMetaData()
  337.      */
  338.     public ResultSetMetaData getMetaData() throws SQLException {
  339.         try {
  340.             if (this.wrappedStmt != null) {
  341.                 return ((PreparedStatement) this.wrappedStmt).getMetaData();
  342.             } else {
  343.                 throw new SQLException("No operations allowed after statement closed",
  344.                     SQLError.SQL_STATE_GENERAL_ERROR);
  345.             }
  346.         } catch (SQLException sqlEx) {
  347.             checkAndFireConnectionError(sqlEx);
  348.         }
  350.         return null;
  351.     }
  353.     /* (non-Javadoc)
  354.      * @see java.sql.PreparedStatement#setNull(int, int)
  355.      */
  356.     public void setNull(int parameterIndex, int sqlType)
  357.         throws SQLException {
  358.         try {
  359.             if (this.wrappedStmt != null) {
  360.                 ((PreparedStatement) this.wrappedStmt).setNull(parameterIndex,
  361.                     sqlType);
  362.             } else {
  363.                 throw new SQLException("No operations allowed after statement closed",
  364.                     SQLError.SQL_STATE_GENERAL_ERROR);
  365.             }
  366.         } catch (SQLException sqlEx) {
  367.             checkAndFireConnectionError(sqlEx);
  368.         }
  369.     }
  371.     /* (non-Javadoc)
  372.      * @see java.sql.PreparedStatement#setNull(int, int, java.lang.String)
  373.      */
  374.     public void setNull(int parameterIndex, int sqlType, String typeName)
  375.         throws SQLException {
  376.         try {
  377.             if (this.wrappedStmt != null) {
  378.                 ((PreparedStatement) this.wrappedStmt).setNull(parameterIndex,
  379.                     sqlType, typeName);
  380.             } else {
  381.                 throw new SQLException("No operations allowed after statement closed",
  382.                     SQLError.SQL_STATE_GENERAL_ERROR);
  383.             }
  384.         } catch (SQLException sqlEx) {
  385.             checkAndFireConnectionError(sqlEx);
  386.         }
  387.     }
  389.     /* (non-Javadoc)
  390.      * @see java.sql.PreparedStatement#setObject(int, java.lang.Object)
  391.      */
  392.     public void setObject(int parameterIndex, Object x)
  393.         throws SQLException {
  394.         try {
  395.             if (this.wrappedStmt != null) {
  396.                 ((PreparedStatement) this.wrappedStmt).setObject(parameterIndex,
  397.                     x);
  398.             } else {
  399.                 throw new SQLException("No operations allowed after statement closed",
  400.                     SQLError.SQL_STATE_GENERAL_ERROR);
  401.             }
  402.         } catch (SQLException sqlEx) {
  403.             checkAndFireConnectionError(sqlEx);
  404.         }
  405.     }
  407.     /* (non-Javadoc)
  408.      * @see java.sql.PreparedStatement#setObject(int, java.lang.Object, int)
  409.      */
  410.     public void setObject(int parameterIndex, Object x, int targetSqlType)
  411.         throws SQLException {
  412.         try {
  413.             if (this.wrappedStmt != null) {
  414.                 ((PreparedStatement) this.wrappedStmt).setObject(parameterIndex,
  415.                     x, targetSqlType);
  416.             } else {
  417.                 throw new SQLException("No operations allowed after statement closed",
  418.                     SQLError.SQL_STATE_GENERAL_ERROR);
  419.             }
  420.         } catch (SQLException sqlEx) {
  421.             checkAndFireConnectionError(sqlEx);
  422.         }
  423.     }
  425.     /* (non-Javadoc)
  426.      * @see java.sql.PreparedStatement#setObject(int, java.lang.Object, int, int)
  427.      */
  428.     public void setObject(int parameterIndex, Object x, int targetSqlType,
  429.         int scale) throws SQLException {
  430.         try {
  431.             if (this.wrappedStmt != null) {
  432.                 ((PreparedStatement) this.wrappedStmt).setObject(parameterIndex,
  433.                     x, scale);
  434.             } else {
  435.                 throw new SQLException("No operations allowed after statement closed",
  436.                     SQLError.SQL_STATE_GENERAL_ERROR);
  437.             }
  438.         } catch (SQLException sqlEx) {
  439.             checkAndFireConnectionError(sqlEx);
  440.         }
  441.     }
  443.     /* (non-Javadoc)
  444.      * @see java.sql.PreparedStatement#getParameterMetaData()
  445.      */
  446.     public ParameterMetaData getParameterMetaData() throws SQLException {
  447.         try {
  448.             if (this.wrappedStmt != null) {
  449.                 return ((PreparedStatement) this.wrappedStmt)
  450.                 .getParameterMetaData();
  451.             } else {
  452.                 throw new SQLException("No operations allowed after statement closed",
  453.                     SQLError.SQL_STATE_GENERAL_ERROR);
  454.             }
  455.         } catch (SQLException sqlEx) {
  456.             checkAndFireConnectionError(sqlEx);
  457.         }
  459.         return null;
  460.     }
  462.     /* (non-Javadoc)
  463.      * @see java.sql.PreparedStatement#setRef(int, java.sql.Ref)
  464.      */
  465.     public void setRef(int parameterIndex, Ref x) throws SQLException {
  466.         try {
  467.             if (this.wrappedStmt != null) {
  468.                 ((PreparedStatement) this.wrappedStmt).setRef(parameterIndex, x);
  469.             } else {
  470.                 throw new SQLException("No operations allowed after statement closed",
  471.                     SQLError.SQL_STATE_GENERAL_ERROR);
  472.             }
  473.         } catch (SQLException sqlEx) {
  474.             checkAndFireConnectionError(sqlEx);
  475.         }
  476.     }
  478.     /* (non-Javadoc)
  479.      * @see java.sql.PreparedStatement#setShort(int, short)
  480.      */
  481.     public void setShort(int parameterIndex, short x) throws SQLException {
  482.         try {
  483.             if (this.wrappedStmt != null) {
  484.                 ((PreparedStatement) this.wrappedStmt).setShort(parameterIndex,
  485.                     x);
  486.             } else {
  487.                 throw new SQLException("No operations allowed after statement closed",
  488.                     SQLError.SQL_STATE_GENERAL_ERROR);
  489.             }
  490.         } catch (SQLException sqlEx) {
  491.             checkAndFireConnectionError(sqlEx);
  492.         }
  493.     }
  495.     /* (non-Javadoc)
  496.      * @see java.sql.PreparedStatement#setString(int, java.lang.String)
  497.      */
  498.     public void setString(int parameterIndex, String x)
  499.         throws SQLException {
  500.         try {
  501.             if (this.wrappedStmt != null) {
  502.                 ((PreparedStatement) this.wrappedStmt).setString(parameterIndex,
  503.                     x);
  504.             } else {
  505.                 throw new SQLException("No operations allowed after statement closed",
  506.                     SQLError.SQL_STATE_GENERAL_ERROR);
  507.             }
  508.         } catch (SQLException sqlEx) {
  509.             checkAndFireConnectionError(sqlEx);
  510.         }
  511.     }
  513.     /* (non-Javadoc)
  514.      * @see java.sql.PreparedStatement#setTime(int, java.sql.Time)
  515.      */
  516.     public void setTime(int parameterIndex, Time x) throws SQLException {
  517.         try {
  518.             if (this.wrappedStmt != null) {
  519.                 ((PreparedStatement) this.wrappedStmt).setTime(parameterIndex, x);
  520.             } else {
  521.                 throw new SQLException("No operations allowed after statement closed",
  522.                     SQLError.SQL_STATE_GENERAL_ERROR);
  523.             }
  524.         } catch (SQLException sqlEx) {
  525.             checkAndFireConnectionError(sqlEx);
  526.         }
  527.     }
  529.     /* (non-Javadoc)
  530.      * @see java.sql.PreparedStatement#setTime(int, java.sql.Time, java.util.Calendar)
  531.      */
  532.     public void setTime(int parameterIndex, Time x, Calendar cal)
  533.         throws SQLException {
  534.         try {
  535.             if (this.wrappedStmt != null) {
  536.                 ((PreparedStatement) this.wrappedStmt).setTime(parameterIndex,
  537.                     x, cal);
  538.             } else {
  539.                 throw new SQLException("No operations allowed after statement closed",
  540.                     SQLError.SQL_STATE_GENERAL_ERROR);
  541.             }
  542.         } catch (SQLException sqlEx) {
  543.             checkAndFireConnectionError(sqlEx);
  544.         }
  545.     }
  547.     /* (non-Javadoc)
  548.      * @see java.sql.PreparedStatement#setTimestamp(int, java.sql.Timestamp)
  549.      */
  550.     public void setTimestamp(int parameterIndex, Timestamp x)
  551.         throws SQLException {
  552.         try {
  553.             if (this.wrappedStmt != null) {
  554.                 ((PreparedStatement) this.wrappedStmt).setTimestamp(parameterIndex,
  555.                     x);
  556.             } else {
  557.                 throw new SQLException("No operations allowed after statement closed",
  558.                     SQLError.SQL_STATE_GENERAL_ERROR);
  559.             }
  560.         } catch (SQLException sqlEx) {
  561.             checkAndFireConnectionError(sqlEx);
  562.         }
  563.     }
  565.     /* (non-Javadoc)
  566.      * @see java.sql.PreparedStatement#setTimestamp(int, java.sql.Timestamp, java.util.Calendar)
  567.      */
  568.     public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal)
  569.         throws SQLException {
  570.         try {
  571.             if (this.wrappedStmt != null) {
  572.                 ((PreparedStatement) this.wrappedStmt).setTimestamp(parameterIndex,
  573.                     x, cal);
  574.             } else {
  575.                 throw new SQLException("No operations allowed after statement closed",
  576.                     SQLError.SQL_STATE_GENERAL_ERROR);
  577.             }
  578.         } catch (SQLException sqlEx) {
  579.             checkAndFireConnectionError(sqlEx);
  580.         }
  581.     }
  583.     /* (non-Javadoc)
  584.      * @see java.sql.PreparedStatement#setURL(int, java.net.URL)
  585.      */
  586.     public void setURL(int parameterIndex, URL x) throws SQLException {
  587.         try {
  588.             if (this.wrappedStmt != null) {
  589.                 ((PreparedStatement) this.wrappedStmt).setURL(parameterIndex, x);
  590.             } else {
  591.                 throw new SQLException("No operations allowed after statement closed",
  592.                     SQLError.SQL_STATE_GENERAL_ERROR);
  593.             }
  594.         } catch (SQLException sqlEx) {
  595.             checkAndFireConnectionError(sqlEx);
  596.         }
  597.     }
  599.     /**
  600.      * DOCUMENT ME!
  601.      *
  602.      * @param parameterIndex DOCUMENT ME!
  603.      * @param x DOCUMENT ME!
  604.      * @param length DOCUMENT ME!
  605.      *
  606.      * @throws SQLException DOCUMENT ME!
  607.      *
  608.      * @see java.sql.PreparedStatement#setUnicodeStream(int,
  609.      *      java.io.InputStream, int)
  610.      * @deprecated
  611.      */
  612.     public void setUnicodeStream(int parameterIndex, InputStream x, int length)
  613.         throws SQLException {
  614.         try {
  615.             if (this.wrappedStmt != null) {
  616.                 ((PreparedStatement) this.wrappedStmt).setUnicodeStream(parameterIndex,
  617.                     x, length);
  618.             } else {
  619.                 throw new SQLException("No operations allowed after statement closed",
  620.                     SQLError.SQL_STATE_GENERAL_ERROR);
  621.             }
  622.         } catch (SQLException sqlEx) {
  623.             checkAndFireConnectionError(sqlEx);
  624.         }
  625.     }
  627.     /* (non-Javadoc)
  628.      * @see java.sql.PreparedStatement#addBatch()
  629.      */
  630.     public void addBatch() throws SQLException {
  631.         try {
  632.             if (this.wrappedStmt != null) {
  633.                 ((PreparedStatement) this.wrappedStmt).addBatch();
  634.             } else {
  635.                 throw new SQLException("No operations allowed after statement closed",
  636.                     SQLError.SQL_STATE_GENERAL_ERROR);
  637.             }
  638.         } catch (SQLException sqlEx) {
  639.             checkAndFireConnectionError(sqlEx);
  640.         }
  641.     }
  643.     /* (non-Javadoc)
  644.      * @see java.sql.PreparedStatement#clearParameters()
  645.      */
  646.     public void clearParameters() throws SQLException {
  647.         try {
  648.             if (this.wrappedStmt != null) {
  649.                 ((PreparedStatement) this.wrappedStmt).clearParameters();
  650.             } else {
  651.                 throw new SQLException("No operations allowed after statement closed",
  652.                     SQLError.SQL_STATE_GENERAL_ERROR);
  653.             }
  654.         } catch (SQLException sqlEx) {
  655.             checkAndFireConnectionError(sqlEx);
  656.         }
  657.     }
  659.     /* (non-Javadoc)
  660.      * @see java.sql.PreparedStatement#execute()
  661.      */
  662.     public boolean execute() throws SQLException {
  663.         try {
  664.             if (this.wrappedStmt != null) {
  665.                 return ((PreparedStatement) this.wrappedStmt).execute();
  666.             } else {
  667.                 throw new SQLException("No operations allowed after statement closed",
  668.                     SQLError.SQL_STATE_GENERAL_ERROR);
  669.             }
  670.         } catch (SQLException sqlEx) {
  671.             checkAndFireConnectionError(sqlEx);
  672.         }
  674.         return false; // we actually never get here, but the compiler can't figure 
  676.         // that out
  677.     }
  679.     /* (non-Javadoc)
  680.      * @see java.sql.PreparedStatement#executeQuery()
  681.      */
  682.     public ResultSet executeQuery() throws SQLException {
  683.         try {
  684.             if (this.wrappedStmt != null) {
  685.                 return ((PreparedStatement) this.wrappedStmt).executeQuery();
  686.             } else {
  687.                 throw new SQLException("No operations allowed after statement closed",
  688.                     SQLError.SQL_STATE_GENERAL_ERROR);
  689.             }
  690.         } catch (SQLException sqlEx) {
  691.             checkAndFireConnectionError(sqlEx);
  692.         }
  694.         return null; // we actually never get here, but the compiler can't figure 
  696.         // that out
  697.     }
  699.     /* (non-Javadoc)
  700.      * @see java.sql.PreparedStatement#executeUpdate()
  701.      */
  702.     public int executeUpdate() throws SQLException {
  703.         try {
  704.             if (this.wrappedStmt != null) {
  705.                 return ((PreparedStatement) this.wrappedStmt).executeUpdate();
  706.             } else {
  707.                 throw new SQLException("No operations allowed after statement closed",
  708.                     SQLError.SQL_STATE_GENERAL_ERROR);
  709.             }
  710.         } catch (SQLException sqlEx) {
  711.             checkAndFireConnectionError(sqlEx);
  712.         }
  714.         return -1; // we actually never get here, but the compiler can't figure 
  716.         // that out
  717.     }
  718. }