PreparedStatementWrapper.java

/*
 * JOnAS: Java(TM) Open Application Server
 * Copyright (C) 1999 Bull S.A.
 * Contact: jonas-team@objectweb.org
 *
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * --------------------------------------------------------------------------
 * $Id: PreparedStatementWrapper.java,v 1.9 2004/11/17 20:54:07 ehardesty Exp $
 * --------------------------------------------------------------------------
 *
 */

package org.objectweb.jonas.resource;

import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.Date;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Arrays;
import java.util.Calendar;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class PreparedStatementWrapper implements PreparedStatement {

    PreparedStatement pstmt = null;

    String user = null;
    String sql = null;

    boolean invalid = false;
    boolean closed = false;

    int hashCode;

    int resultSetType = -1;
    int resultSetConcurrency = -1;
//  JDK1.4
    int resultSetHoldability = -1;

//  JDK1.4
    int autoGeneratedKeys = -1;
    int [] columnIndexes = null;
    String [] columnNames = null;

    Logger trace = null;

    public PreparedStatementWrapper(String _user, String _sql,
                                     int _resultSetType,
                                     int _resultSetConcurrency,
                                     Logger _trace) {

        if (_user != null) {
            user = _user.trim();
        } else {
            user = null;
        }
        if (_sql != null) {
            sql = _sql.trim();
        } else {
            sql = null;
        }
        resultSetType = _resultSetType;
        resultSetConcurrency = _resultSetConcurrency;
        trace = _trace;
        String hashStr = user + sql + resultSetType + resultSetConcurrency;
        hashCode = hashStr.hashCode();
    }

// JDK1.4
    public PreparedStatementWrapper(String _user, String _sql, 
                                     int _resultSetType,
                                     int _resultSetConcurrency,
                                     int _resultSetHoldability,
                                     Logger _trace) {

        user = _user;
        sql = _sql;
        resultSetType = _resultSetType;
        resultSetConcurrency = _resultSetConcurrency;
        resultSetHoldability = _resultSetHoldability;
        trace = _trace;
        String hashStr = user + sql + resultSetType + resultSetConcurrency + resultSetHoldability;
        hashCode = hashStr.hashCode();
    }


// JDK1.4
    public PreparedStatementWrapper(String _user, String _sql,
                                     int _autoGeneratedKeys,
                                     Logger _trace) {
                                     
        user = _user;
        sql = _sql;
        autoGeneratedKeys = _autoGeneratedKeys;
        trace = _trace;
        String hashStr = user + sql + autoGeneratedKeys;
        hashCode = hashStr.hashCode();
    }

//  JDK1.4
    public PreparedStatementWrapper(String _user, String _sql, 
                                     int [] _columnIndexes,
                                     Logger _trace) {

        user = _user;
        sql = _sql;
        columnIndexes = _columnIndexes;
        trace = _trace;
        String hashStr = user + sql + columnIndexes;
        hashCode = hashStr.hashCode();
    }

    //  JDK1.4
    public PreparedStatementWrapper(String _user, String _sql, 
                                     String [] _columnNames,
                                     Logger _trace) {

        user = _user;
        sql = _sql;
        columnNames = _columnNames;
        trace = _trace;
        String hashStr = user + sql + columnNames;
        hashCode = hashStr.hashCode();
    }

    public void checkIfValid() throws SQLException {
        if (invalid) {
            SQLException se = new SQLException("PreparedStatement(" + this + ") is invalid.");
            se.printStackTrace();
            throw se;
        }

    }

    public void clearPstmtValues() throws SQLException {
        closed = false;
        try {
            pstmt.clearParameters();
            pstmt.clearBatch();
        } catch (Throwable ex) { }
        try {
            pstmt.setEscapeProcessing(true);
        } catch (Throwable ex) { }
        try {
            pstmt.setFetchDirection(ResultSet.FETCH_FORWARD);
        } catch (Throwable ex) { }
        try {
            pstmt.setMaxFieldSize(0);
        } catch (Throwable ex) { }
        try {
            pstmt.setMaxRows(0);
        } catch (Throwable ex) { }
        try {
            pstmt.setQueryTimeout(0);
        } catch (Throwable ex) { }
        try {
            pstmt.clearWarnings();
        } catch (Throwable ex) { }
        }

    public void closePstmt() throws SQLException {
        closed = true;
        try {
            pstmt.close();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void destroy() throws SQLException {
        trace.log(BasicLevel.DEBUG, "" + this);
        try {
            pstmt.close();
        } catch (SQLException e) {
            throw(e);
        }
        invalid = true;
        closed = true;
    }

    public boolean equals(Object stmt) {
        trace.log(BasicLevel.DEBUG, "");
        if (stmt == null || !(stmt instanceof PreparedStatementWrapper)) {
            return false;
        }
        PreparedStatementWrapper psw = (PreparedStatementWrapper) stmt;
        if (invalid) {
            trace.log(BasicLevel.DEBUG, "Prepared Statement is invalid");
            return false;
        }
        if (hashCode != psw.hashCode) {
            trace.log(BasicLevel.DEBUG, "Hashcode of: " + psw.sql + " not equal to " + sql);
            return false;
        }
        if (sql == null && psw.sql != null) {
            trace.log(BasicLevel.DEBUG, "Stmt sql: " + psw.sql + " not equal to " + sql);
            return false;
        }
        if (sql != null && !sql.equals(psw.sql)) {
            trace.log(BasicLevel.DEBUG, "Stmt sql: " + psw.sql + " not equal to " + sql);
            return false;
        }
        if (user == null && psw.user != null) {
            trace.log(BasicLevel.DEBUG, "Stmt user: " + psw.user + " not equal to " + user);
            return false;
        }
        if (user != null && !user.equals(psw.user)) {
            trace.log(BasicLevel.DEBUG, "Stmt user: " + psw.user + " not equal to " + user);
            return false;
        }
        if (resultSetType != psw.resultSetType) {
            trace.log(BasicLevel.DEBUG, "Stmt resultSetType: " + psw.resultSetType + " not equal to "
                                        + resultSetType);
            return false;
        }
        if (resultSetConcurrency != psw.resultSetConcurrency) {
            trace.log(BasicLevel.DEBUG, "Stmt resultSetConcurrency: " + psw.resultSetConcurrency
                                        + " not equal to " + resultSetConcurrency);
            return false;
        }
        if (resultSetHoldability != psw.resultSetHoldability) {
            trace.log(BasicLevel.DEBUG, "Stmt resultSetHoldability: " + psw.resultSetHoldability
                                        + " not equal to " + resultSetHoldability);
            return false;
        }
        if (autoGeneratedKeys != psw.autoGeneratedKeys) {
            trace.log(BasicLevel.DEBUG, "Stmt autoGeneratedKeys: " + psw.autoGeneratedKeys
                                        + " not equal to " + autoGeneratedKeys);
            return false;
        }
        if (!Arrays.equals(columnIndexes, psw.columnIndexes)) {
            trace.log(BasicLevel.DEBUG, "Stmt columnIndexes: " + psw.columnIndexes + " not equal to "
                                        + columnIndexes);
            return false;
        }
        if (!Arrays.equals(columnNames, psw.columnNames)) {
            trace.log(BasicLevel.DEBUG, "Stmt columnNames: " + psw.columnNames + " not equal to "
                                        + columnNames);
            return false;
        }
        trace.log(BasicLevel.DEBUG, "Stmt found at " + this);
        return true;
    }

    public void setClosed(boolean val) {
        closed = val;
    }

    public void setPreparedStatement(PreparedStatement _pstmt) {
        pstmt = _pstmt;
    }

/* *********************
   Prepared Statment calls
*/


    public void addBatch() throws SQLException {
        checkIfValid();
        try {
            pstmt.addBatch();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void clearParameters() throws SQLException {
        checkIfValid();
        try {
            pstmt.clearParameters();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public boolean execute() throws SQLException {
        checkIfValid();
        try {
            return pstmt.execute();
        } catch (SQLException e) {
            throw(e);
        }
    }

//  JDK1.4
    public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
        checkIfValid();
        try {
            return pstmt.execute(sql, autoGeneratedKeys);
        } catch (SQLException e) {
            throw(e);
        }
    }

//  JDK1.4
    public boolean execute(String sql, int [] columnIndexes) throws SQLException {
        checkIfValid();
        try {
            return pstmt.execute(sql, columnIndexes);
        } catch (SQLException e) {
            throw(e);
        }
    }

//  JDK1.4
    public boolean execute(String sql, String [] columnNames) throws SQLException {
        checkIfValid();
        try {
            return pstmt.execute(sql, columnNames);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public ResultSet executeQuery() throws SQLException {
        checkIfValid();
        try {
            return pstmt.executeQuery();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public int executeUpdate() throws SQLException {
    checkIfValid();
        try {
            return pstmt.executeUpdate();
        } catch (SQLException e) {
            throw(e);
        }
    }

//  JDK1.4
    public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
        checkIfValid();
        try {
            return pstmt.executeUpdate(sql, autoGeneratedKeys);
        } catch (SQLException e) {
            throw(e);
        }
    }

//  JDK1.4
    public int executeUpdate(String sql, int[] columnIndexes) throws SQLException {
        checkIfValid();
        try {
            return pstmt.executeUpdate(sql, columnIndexes);
        } catch (SQLException e) {
            throw(e);
        }
    }

//  JDK1.4
    public int executeUpdate(String sql, String[] columnNames) throws SQLException {
        checkIfValid();
        try {
            return pstmt.executeUpdate(sql, columnNames);
        } catch (SQLException e) {
            throw(e);
        }
    }

//  JDK1.4
    public ResultSet getGeneratedKeys() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getGeneratedKeys();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public ResultSetMetaData getMetaData() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getMetaData();
        } catch (SQLException e) {
            throw(e);
        }
    }

//  JDK1.4
    public boolean getMoreResults(int current) throws SQLException {
        checkIfValid();
        try {
            return pstmt.getMoreResults(current);
        } catch (SQLException e) {
            throw(e);
        }
    }

//  JDK1.4
    public ParameterMetaData getParameterMetaData() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getParameterMetaData();
        } catch (SQLException e) {
            throw(e);
        }
    }

//  JDK1.4
    public int getResultSetHoldability() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getResultSetHoldability();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setArray(int i, Array x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setArray(i, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
        checkIfValid();
        try {
            pstmt.setAsciiStream(parameterIndex, x, length);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setBigDecimal(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
        checkIfValid();
        try {
            pstmt.setBinaryStream(parameterIndex, x, length);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setBlob(int i, Blob x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setBlob(i, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setBoolean(int parameterIndex, boolean x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setBoolean(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setByte(int parameterIndex, byte x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setByte(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setBytes(int parameterIndex, byte [] x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setBytes(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
        checkIfValid();
        try {
            pstmt.setCharacterStream(parameterIndex, reader, length);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setClob(int i, Clob x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setClob(i, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setDate(int parameterIndex, Date x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setDate(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
        checkIfValid();
        try {
            pstmt.setDate(parameterIndex, x, cal);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setDouble(int parameterIndex, double x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setDouble(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setFloat(int parameterIndex, float x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setFloat(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setInt(int parameterIndex, int x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setInt(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setLong(int parameterIndex, long x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setLong(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setNull(int parameterIndex, int sqlType) throws SQLException {
        checkIfValid();
        try {
            pstmt.setNull(parameterIndex, sqlType);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
        checkIfValid();
        try {
            pstmt.setNull(paramIndex, sqlType, typeName);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setObject(int parameterIndex, Object x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setObject(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
        checkIfValid();
        try {
            pstmt.setObject(parameterIndex, x, targetSqlType);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException {
        checkIfValid();
        try {
            pstmt.setObject(parameterIndex, x, targetSqlType, scale);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setRef(int i, Ref x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setRef(i, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setShort(int parameterIndex, short x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setShort(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setString(int parameterIndex, String x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setString(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setTime(int parameterIndex, Time x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setTime(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException  {
        checkIfValid();
        try {
            pstmt.setTime(parameterIndex, x, cal);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setTimestamp(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
        checkIfValid();
        try {
            pstmt.setTimestamp(parameterIndex, x, cal);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
        checkIfValid();
        try {
            pstmt.setUnicodeStream(parameterIndex, x, length);
        } catch (SQLException e) {
            throw(e);
        }
    }


    // Statement interface

    public void addBatch(String s) throws SQLException {
        checkIfValid();
        try {
            pstmt.addBatch(s);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void cancel() throws SQLException {
        checkIfValid();
        try {
            pstmt.cancel();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void clearBatch() throws SQLException {
        checkIfValid();
        try {
            pstmt.clearBatch();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void clearWarnings() throws SQLException {
        checkIfValid();
        try {
            pstmt.clearWarnings();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void close() throws SQLException {
        trace.log(BasicLevel.DEBUG, "" + this);
        closed = true;
/*        try {
            pstmt.close();
        } catch (SQLException e) {
            throw(e);
        }
        //clearPstmtValues();
*/
    }

    public boolean execute(String s) throws SQLException {
        checkIfValid();
        try {
            return pstmt.execute(s);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public int[] executeBatch() throws SQLException {
        checkIfValid();
        try {
            return pstmt.executeBatch();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public ResultSet executeQuery(String s) throws SQLException {
        checkIfValid();
        try {
            return pstmt.executeQuery(s);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public int executeUpdate(String s) throws SQLException {
        checkIfValid();
        try {
            return pstmt.executeUpdate(s);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public Connection getConnection() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getConnection();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public int getFetchDirection() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getFetchDirection();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public int getFetchSize() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getFetchSize();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public int getMaxFieldSize() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getMaxFieldSize();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public int getMaxRows() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getMaxRows();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public boolean getMoreResults() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getMoreResults();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public int getQueryTimeout() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getQueryTimeout();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public ResultSet getResultSet() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getResultSet();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public int getResultSetConcurrency() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getResultSetConcurrency();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public int getResultSetType() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getResultSetType();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public int getUpdateCount() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getUpdateCount();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public SQLWarning getWarnings() throws SQLException {
        checkIfValid();
        try {
            return pstmt.getWarnings();
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setCursorName(String name) throws SQLException {
        checkIfValid();
        try {
            pstmt.setCursorName(name);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setEscapeProcessing(boolean enable) throws SQLException {
        checkIfValid();
        try {
            pstmt.setEscapeProcessing(enable);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setFetchDirection(int direction) throws SQLException {
        checkIfValid();
        try {
            pstmt.setFetchDirection(direction);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setFetchSize(int rows) throws SQLException {
        checkIfValid();
        try {
            pstmt.setFetchSize(rows);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setMaxFieldSize(int max) throws SQLException {
        checkIfValid();
        try {
            pstmt.setMaxFieldSize(max);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setMaxRows(int max) throws SQLException {
        checkIfValid();
        try {
            pstmt.setMaxRows(max);
        } catch (SQLException e) {
            throw(e);
        }
    }

    public void setQueryTimeout(int seconds) throws SQLException {
        checkIfValid();
        try {
            pstmt.setQueryTimeout(seconds);
        } catch (SQLException e) {
            throw(e);
        }
    }

//  JDK1.4
    public void setURL(int parameterIndex, URL x) throws SQLException {
        checkIfValid();
        try {
            pstmt.setURL(parameterIndex, x);
        } catch (SQLException e) {
            throw(e);
        }
    }

}

---