preparedstatementproxy.java

第三方的SQL Server and Sybase的jdbc dirver,速度更快

     * @throws SQLException if an error occurs
     */
    public void setUnicodeStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setUnicodeStream(parameterIndex, x, length);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setBinaryStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setBinaryStream(parameterIndex, x, length);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void clearParameters() throws SQLException {
        validateConnection();

        try {
            _preparedStatement.clearParameters();
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setObject(parameterIndex, x, targetSqlType, scale);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setObject(parameterIndex, x, targetSqlType);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setObject(int parameterIndex, Object x) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setObject(parameterIndex, x);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public boolean execute() throws SQLException {
        validateConnection();

        try {
            return _preparedStatement.execute();
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
        
        return false;
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void addBatch() throws SQLException {
        validateConnection();

        try {
            _preparedStatement.addBatch();
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setCharacterStream(int parameterIndex, java.io.Reader x, int length) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setCharacterStream(parameterIndex, x, length);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setRef(int parameterIndex, Ref x) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setRef(parameterIndex, x);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setBlob(int parameterIndex, Blob x) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setBlob(parameterIndex, x);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setClob(int parameterIndex, Clob x) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setClob(parameterIndex, x);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setArray(int parameterIndex, Array x) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setArray(parameterIndex, x);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public ResultSetMetaData getMetaData() throws SQLException {
        validateConnection();

        try {
            return _preparedStatement.getMetaData();
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
        
        return null;
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setDate(int parameterIndex, java.sql.Date x, Calendar cal) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setDate(parameterIndex, x, cal);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setTime(int parameterIndex, java.sql.Time x, Calendar cal) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setTime(parameterIndex, x, cal);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setTimestamp(int parameterIndex, java.sql.Timestamp x, Calendar cal) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setTimestamp(parameterIndex, x, cal);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setNull (int parameterIndex, int sqlType, String typeName) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setNull(parameterIndex, sqlType, typeName);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public void setURL(int parameterIndex, java.net.URL x) throws SQLException {
        validateConnection();

        try {
            _preparedStatement.setURL(parameterIndex, x);
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
    }

    /**
     * Delgates calls to the prepared statement; SQLExceptions thrown from the
     * prepared statement will cause an event to be fired on the connection
     * pool listeners.
     *
     * @throws SQLException if an error occurs
     */
    public ParameterMetaData getParameterMetaData() throws SQLException {
        validateConnection();

        try {
            return _preparedStatement.getParameterMetaData();
        } catch (SQLException sqlException) {
            processSQLException(sqlException);
        }
        
        return null;
    }
}