legacydbconnectionfactory.java

opennms得相关源码 请大家看看

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
            checkAccess();
            try {
                return m_delegate.prepareStatement(sql, autoGeneratedKeys);
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
            checkAccess();
            try {
                return m_delegate.prepareStatement(sql, columnIndexes);
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
            checkAccess();
            try {
                return m_delegate.prepareStatement(sql, columnNames);
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public CallableStatement prepareCall(String sql) throws SQLException {
            checkAccess();
            try {
                return m_delegate.prepareCall(sql);
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public String nativeSQL(String sql) throws SQLException {
            checkAccess();
            try {
                return m_delegate.nativeSQL(sql);
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public void setAutoCommit(boolean autoCommit) throws SQLException {
            checkAccess();
            try {
                m_delegate.setAutoCommit(autoCommit);
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public boolean getAutoCommit() throws SQLException {
            checkAccess();
            try {
                return m_delegate.getAutoCommit();
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public void commit() throws SQLException {
            checkAccess();
            try {
                m_delegate.commit();
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public void rollback() throws SQLException {
            checkAccess();
            try {
                m_delegate.rollback();
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        public void rollback(Savepoint savepoint) throws SQLException {
            checkAccess();
            try {
                m_delegate.rollback(savepoint);
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public DatabaseMetaData getMetaData() throws SQLException {
            checkAccess();
            try {
                return m_delegate.getMetaData();
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public void setReadOnly(boolean readOnly) throws SQLException {
            checkAccess();
            try {
                m_delegate.setReadOnly(readOnly);
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public boolean isReadOnly() throws SQLException {
            checkAccess();
            try {
                return m_delegate.isReadOnly();
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public void setCatalog(String catalog) throws SQLException {
            checkAccess();
            try {
                m_delegate.setCatalog(catalog);
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public String getCatalog() throws SQLException {
            checkAccess();
            try {
                return m_delegate.getCatalog();
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public void setTransactionIsolation(int level) throws SQLException {
            checkAccess();
            try {
                m_delegate.setTransactionIsolation(level);
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public int getTransactionIsolation() throws SQLException {
            checkAccess();
            try {
                return m_delegate.getTransactionIsolation();
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.
         * 
         * @throws java.sql.SQLException
         *             May be thrown by the encapsulated connection
         */
        public SQLWarning getWarnings() throws SQLException {
            checkAccess();
            try {
                return m_delegate.getWarnings();
            } catch (SQLException ex) {
                m_hadError = true;
                ThreadCategory.getInstance(getClass()).debug("setting bad flag [id=" + this + "]", ex);
                throw ex;
            }
        }

        /**
         * Forwards the request to the encapsulated connection after access to
         * the connection is granted.