ConnectionImpl.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.1 of the License, or 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: ConnectionImpl.java,v 1.11 2004/10/18 11:54:06 durieuxp Exp $
 * --------------------------------------------------------------------------
 */


package org.objectweb.jonas.jdbc_xa;

import java.sql.*;
import java.util.Map;

import org.objectweb.jonas.common.Log;
import org.objectweb.util.monolog.api.Logger;
import org.objectweb.util.monolog.api.BasicLevel;

public class ConnectionImpl implements Connection {
        
    static private Logger logger = null;
        
    protected Connection actConn = null;
    protected XAConnectionImpl xac = null;
    protected boolean autocommit_set = false;
    protected boolean autocommit_unset = false;
    static private Class implclass = null;
        
    // -----------------------------------------------------------------
    // Constructors
    // -----------------------------------------------------------------

    public ConnectionImpl(XAConnectionImpl xac, Connection actual) {
        this.xac = xac;
        actConn = actual;
        logger = Log.getLogger(Log.JONAS_JDBCXA_PREFIX);
    }

    

    // -----------------------------------------------------------------
    // Accessors
    // -----------------------------------------------------------------

    public Connection getConnection() {
        logger.log(BasicLevel.DEBUG, "");
        return actConn;
    }
        
    // -----------------------------------------------------------------
    // Connection implementation
    // Most of the methods just forward the call to the actual connection.
    // -----------------------------------------------------------------
        
    public Statement createStatement() 
        throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.createStatement();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }



    public PreparedStatement prepareStatement(String sql) 
        throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.prepareStatement(sql);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }

    public CallableStatement prepareCall(String sql) 
        throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.prepareCall(sql);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
        
    public String nativeSQL(String sql) 
        throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.nativeSQL(sql);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
        
    public boolean isPhysicallyClosed() 
        throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        return actConn.isClosed();
    }

    public boolean isClosed() 
        throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");

        // TODO : This should return the status of the connection viewed from the user,
        // not the physical connection!
        try {
            return actConn.isClosed();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }

    public DatabaseMetaData getMetaData() 
        throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.getMetaData();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }

    public void setReadOnly(boolean readOnly) 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            actConn.setReadOnly(readOnly);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }

    public boolean isReadOnly() 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.isReadOnly();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public void setCatalog(String catalog) 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            actConn.setCatalog(catalog);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }

    public String getCatalog() 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.getCatalog();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
        
    public void close() 
    throws SQLException {
        logger.log(BasicLevel.DEBUG, "");
        xac.notifyClose();
    }
        
    public void setTransactionIsolation(int level) 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            actConn.setTransactionIsolation(level);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
        
    public int getTransactionIsolation() 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.getTransactionIsolation();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
        
    public SQLWarning getWarnings() 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.getWarnings();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
        
    public void clearWarnings() 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            actConn.clearWarnings();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
        
    public void commit() 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "local transaction");
        try {
            actConn.commit();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public void rollback() 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "local transaction");
        try {
            actConn.rollback();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }

    public void setAutoCommit(boolean autoCommit) 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, " ");
        try {
            if (autoCommit == false) {
                if (autocommit_unset == false) { // cache for optimization
                    actConn.setAutoCommit(false);
                    autocommit_set = false;
                    autocommit_unset = true;
                }
            } else {
                if (autocommit_set == false) { // cache for optimization
                    actConn.setAutoCommit(true);
                    autocommit_set = true;
                    autocommit_unset = false;
                }
            }
        } catch (SQLException e) {
            String s = e.getMessage().toLowerCase();
            if (s.indexOf("set chained command not allowed") != -1) {
                logger.log(BasicLevel.DEBUG, "failed...");
                logger.log(BasicLevel.DEBUG, "Committing then retrying");
                try {
                    // These lines for Sybase only, hoping they don't broke
                    // anything for others DBs.
                    actConn.commit();
                    actConn.setAutoCommit(autoCommit); // Shouldn't fail now.
                    logger.log(BasicLevel.DEBUG, "succeeded after retry");
                } catch (SQLException se) {
                    logger.log(BasicLevel.ERROR,"" + autoCommit + ") failed again after retry");
                    logger.log(BasicLevel.ERROR,"Exception: "+se);
                    xac.notifyError(e);
                    throw(e);
                }
            } else {
                logger.log(BasicLevel.ERROR,"setAutoCommit(" + autoCommit + ") failed: "+e);
                xac.notifyError(e);
                throw(e);
            }
        }
    }

    public boolean getAutoCommit() 
    throws SQLException {
        
        try {
            return actConn.getAutoCommit();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }

    public Statement createStatement(int resultSetType, int resultSetConcurrency) 
        throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.createStatement(resultSetType, resultSetConcurrency);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public Map getTypeMap() 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.getTypeMap();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }

    public void setTypeMap(Map map) 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            setTypeMap(map);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) 
        throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.prepareStatement(sql, resultSetType, resultSetConcurrency);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }

    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) 
        throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.prepareCall(sql, resultSetType, resultSetConcurrency);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }

    public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public int getHoldability() throws SQLException {
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.getHoldability();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) 
    throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) 
        throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        try {
            return actConn.prepareStatement(sql, autoGeneratedKeys);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public PreparedStatement prepareStatement(String sql,
                                              int resultSetType,
                                              int resultSetConcurrency,
                                              int resultSetHoldability) 
        throws SQLException {
        
        logger.log(BasicLevel.DEBUG, "");
        
        try {
            return actConn.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public PreparedStatement prepareStatement(String sql,
                                              int[] columnIndexes) 
    throws SQLException {
        logger.log(BasicLevel.DEBUG, "");
        
        try {
            return actConn.prepareStatement(sql, columnIndexes);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public PreparedStatement prepareStatement(String sql,
                                              String[] columnNames) 
    throws SQLException {
        logger.log(BasicLevel.DEBUG, "");
        
        try {
            return actConn.prepareStatement(sql, columnNames);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public void releaseSavepoint(java.sql.Savepoint savepoint) 
    throws SQLException {
        logger.log(BasicLevel.DEBUG, "");
        
        try {
            actConn.releaseSavepoint(savepoint);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public void rollback(java.sql.Savepoint savepoint) 
    throws SQLException {
        logger.log(BasicLevel.DEBUG, "");
        
        try {
            actConn.rollback(savepoint);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public void setHoldability(int holdability) 
    throws SQLException {
        logger.log(BasicLevel.DEBUG, "");
        
        try {
            actConn.setHoldability(holdability);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public java.sql.Savepoint setSavepoint() 
    throws SQLException {
        logger.log(BasicLevel.DEBUG, "");
        
        try {
            return actConn.setSavepoint();
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }
    
    public java.sql.Savepoint setSavepoint(String name) 
    throws SQLException {
        logger.log(BasicLevel.DEBUG, "");
        
        try {
            return actConn.setSavepoint(name);
        } catch (SQLException e) {
            xac.notifyError(e);
            throw(e);
        }
    }

}

---