Examples of PooledConnection

anvil.database.PooledConnection
Abstract class wrapping connection objects. @version $Revision: 1.2 $ @author Jani Lehtim�ki
javax.sql.PooledConnection
An interface which provides facilities for handling connections to a database which are pooled.
Typically, a PooledConnection is recycled when it is no longer required by an application, rather than being closed and discarded. The reason for treating connections in this way is that it can be an expensive process both to establish a connection to a database and to destroy the connection. Reusing connections through a pool is a way of improving system performance and reducing overhead.
It is not intended that an application use the PooledConnection interface directly. The PooledConnection interface is intended for use by a component called a Connection Pool Manager, typically part of the infrastructure that supports use of the database by applications.
Applications obtain connections to the database by calling the DataSource.getConnection method. Under the covers, the Connection Pool Manager will get a PooledConnection object from its connection pool and passes back a Connection object that wraps or references the PooledConnection object. A new PooledConnection object will only be created if the pool is empty.
When the application is finished using a PooledConnection, the application calls the Connection.close method. The Connection Pool Manager is notified via a ConnectionEvent from the Connection that this has happened (the Pool Manager registers itself with the Connection before the Connection is given to the application). The Pool Manager removes the underlying PooledConnection object from the Connection and returns it to the pool for reuse - the PooledConnection is thus recycled rather than being destroyed.
The connection to the database represented by the PooledConnection is kept open until the PooledConnection object itself is deactivated by the Connection Pool Manager, which calls the PooledConnection.close method. This is typically done if there are too many inactive connections in the pool, if the PooledConnection encounters a problem that makes it unusable or if the whole system is being shut down.
org.apache.activemq.jms.pool.PooledConnection
s.org/">Jencks such as in this example
org.apache.aries.transaction.jms.internal.PooledConnection
s.org/">Jencks such as in this example
org.apache.tomcat.jdbc.pool.PooledConnection
Represents a pooled connection and holds a reference to the {@link java.sql.Connection} object @author Filip Hanik @version 1.0

Examples of javax.sql.PooledConnection

    /**
     * If a fatal error occurs, close the underlying physical connection so as
     * not to be returned in the future
     */
    public void connectionErrorOccurred(ConnectionEvent event) {
        PooledConnection pc = (PooledConnection)event.getSource();
        if (null != event.getSQLException()) {
            System.err
                .println("CLOSING DOWN CONNECTION DUE TO INTERNAL ERROR (" +
                         event.getSQLException() + ")");
        }
        pc.removeConnectionEventListener(this);


        PooledConnectionAndInfo info = (PooledConnectionAndInfo) pcMap.get(pc);
        if (info == null) {
            throw new IllegalStateException(NO_KEY_MESSAGE);
        }

View Full Code Here

Examples of javax.sql.PooledConnection

                    + " doesn't implement javax.sql.ConnectionPoolDataSource");
            }
        }
        
        // try to get a connection with the supplied username/password
        PooledConnection conn = null;
        try {
            if (username != null) {
                conn = cpds.getPooledConnection(username, password);
            }
            else {
                conn = cpds.getPooledConnection();
            }
            if (conn == null) {
                throw new SQLException(
                    "Cannot connect using the supplied username/password");
            }
        }
        finally {
            if (conn != null) {
                try {
                    conn.close();
                }
                catch (SQLException e) {
                    // at least we could connect
                }
            }

View Full Code Here

Examples of javax.sql.PooledConnection

     }


    public synchronized Object makeObject() {
        Object obj;
        try {
            PooledConnection pc = null;
            if (_username == null) {
                pc = _cpds.getPooledConnection();
            } else {
                pc = _cpds.getPooledConnection(_username, _password);
            }


            if (pc == null) {
                throw new IllegalStateException("Connection pool data source returned null from getPooledConnection");
            }


            // should we add this object as a listener or the pool.
            // consider the validateObject method in decision
            pc.addConnectionEventListener(this);
            obj = new PooledConnectionAndInfo(pc, _username, _password);
            pcMap.put(pc, obj);
        } catch (SQLException e) {
            throw new RuntimeException(e.getMessage());
        }

View Full Code Here

Examples of javax.sql.PooledConnection

    /**
     * Closes the PooledConnection and stops listening for events from it.
     */
    public void destroyObject(Object obj) throws Exception {
        if (obj instanceof PooledConnectionAndInfo) {
            PooledConnection pc = ((PooledConnectionAndInfo)obj).getPooledConnection();
            pc.removeConnectionEventListener(this);
            pcMap.remove(pc);
            pc.close(); 
        }
    }

View Full Code Here

Examples of javax.sql.PooledConnection

    }


    public boolean validateObject(Object obj) {
        boolean valid = false;
        if (obj instanceof PooledConnectionAndInfo) {
            PooledConnection pconn =
                ((PooledConnectionAndInfo) obj).getPooledConnection();
            String query = _validationQuery;
            if (null != query) {
                Connection conn = null;
                Statement stmt = null;
                ResultSet rset = null;
                // logical Connection from the PooledConnection must be closed
                // before another one can be requested and closing it will
                // generate an event. Keep track so we know not to return
                // the PooledConnection
                validatingMap.put(pconn, null);
                try {
                    conn = pconn.getConnection();
                    stmt = conn.createStatement();
                    rset = stmt.executeQuery(query);
                    if (rset.next()) {
                        valid = true;
                    } else {

View Full Code Here

Examples of javax.sql.PooledConnection

     * method came from a PooledConnection, and the user calls the close()
     * method of this connection object. What we need to do here is to
     * release this PooledConnection from our pool...
     */
    public void connectionClosed(ConnectionEvent event) {
        PooledConnection pc = (PooledConnection) event.getSource();
        // if this event occured becase we were validating, ignore it
        // otherwise return the connection to the pool.
        if (!validatingMap.containsKey(pc)) {
            Object info = pcMap.get(pc);
            if (info == null) {
                throw new IllegalStateException(NO_KEY_MESSAGE);
            }


            try {
                _pool.returnObject(info);
            } catch (Exception e) {
                System.err.println("CLOSING DOWN CONNECTION AS IT COULD "
                        + "NOT BE RETURNED TO THE POOL");
                pc.removeConnectionEventListener(this);
                try {
                    destroyObject(info);
                } catch (Exception e2) {
                    System.err.println("EXCEPTION WHILE DESTROYING OBJECT "
                            + info);

View Full Code Here

Examples of javax.sql.PooledConnection

    /**
     * If a fatal error occurs, close the underlying physical connection so as
     * not to be returned in the future
     */
    public void connectionErrorOccurred(ConnectionEvent event) {
        PooledConnection pc = (PooledConnection)event.getSource();
        if (null != event.getSQLException()) {
            System.err.println(
                    "CLOSING DOWN CONNECTION DUE TO INTERNAL ERROR ("
                    + event.getSQLException() + ")");
        }
        pc.removeConnectionEventListener(this);


        Object info = pcMap.get(pc);
        if (info == null) {
            throw new IllegalStateException(NO_KEY_MESSAGE);
        }

View Full Code Here

Examples of javax.sql.PooledConnection


                final boolean connectionTesterIsDefault = (connectionTester instanceof DefaultConnectionTester);
 
                public Object acquireResource() throws Exception
                { 
                    PooledConnection out;


                    if ( connectionCustomizer == null)
                    {
                        out = (auth.equals( C3P0ImplUtils.NULL_AUTH ) ?
                               cpds.getPooledConnection() :
                               cpds.getPooledConnection( auth.getUser(), 
                                                         auth.getPassword() ) );
                    }
                    else
                    {
                        try
                        { 
                            WrapperConnectionPoolDataSourceBase wcpds = (WrapperConnectionPoolDataSourceBase) cpds;


                            out = (auth.equals( C3P0ImplUtils.NULL_AUTH ) ?
                                   wcpds.getPooledConnection( connectionCustomizer, parentDataSourceIdentityToken ) :
                                   wcpds.getPooledConnection( auth.getUser(), 
                                                              auth.getPassword(),
                                                              connectionCustomizer, parentDataSourceIdentityToken ) );
                        }
                        catch (ClassCastException e)
                        {
                            throw SqlUtils.toSQLException("Cannot use a ConnectionCustomizer with a non-c3p0 ConnectionPoolDataSource." +
                                            " ConnectionPoolDataSource: " + cpds.getClass().getName(), e);
                        }
                    }


                    //connectionCounter.increment(); 
                    //totalOpenedCounter.increment();


                    try
                    {
                        if (scache != null)
                        {
                            if (c3p0PooledConnections)
                                ((AbstractC3P0PooledConnection) out).initStatementCache(scache);
                            else
                            {
                                // System.err.print("Warning! StatementPooling not ");
                                // System.err.print("implemented for external (non-c3p0) ");
                                // System.err.println("ConnectionPoolDataSources.");


                                logger.warning("StatementPooling not " +
                                                "implemented for external (non-c3p0) " +
                                "ConnectionPoolDataSources.");
                            }
                        }
                        
                        // log and clear any SQLWarnings present upon acquisition
                        Connection con = null;
                        try
                        {
                            waitMarkPooledConnectionInUse(out);
                            con = out.getConnection();
                            SQLWarnings.logAndClearWarnings( con );
                        }
                        finally
                        {
                            //invalidate the proxy Connection
                            ConnectionUtils.attemptClose( con );


                            unmarkPooledConnectionInUse(out);
                        }
                        
                        return out;
                    }
                    catch (Exception e)
                    {
                        if (logger.isLoggable( MLevel.WARNING ))
                            logger.log(MLevel.WARNING,
               "A PooledConnection was acquired, but an Exception occurred while preparing it for use. Attempting to destroy.",
               e);
                        try { destroyResource( out, false ); }
                        catch (Exception e2)
                        {
                            if (logger.isLoggable( MLevel.WARNING ))
                                logger.log( MLevel.WARNING, 
                                                "An Exception occurred while trying to close partially acquired PooledConnection.",
                                                e2 );
                        }


                        throw e;
                    }
                    finally
                    {
                        if (logger.isLoggable( MLevel.FINEST ))
                            logger.finest(this + ".acquireResource() returning. " );
                        //"Currently open Connections: " + connectionCounter.getValue() +
                        //"; Failed close count: " + failedCloseCounter.getValue() +
                        //"; Total processed by this pool: " + totalOpenedCounter.getValue());
                    }
                }


                // REFURBISHMENT:
                // the PooledConnection refurbishes itself when 
                // its Connection view is closed, prior to being
                // checked back in to the pool. But we still may want to
                // test to make sure it is still good.


                public void refurbishResourceOnCheckout( Object resc ) throws Exception
                {
                    if ( connectionCustomizer != null )
                    {
                        Connection physicalConnection = null;
                        try
                        { 
                            physicalConnection =  ((AbstractC3P0PooledConnection) resc).getPhysicalConnection();
                            waitMarkPhysicalConnectionInUse( physicalConnection );
          if ( testConnectionOnCheckout )
        {
            if ( Debug.DEBUG && logger.isLoggable( MLevel.FINER ) )
          finerLoggingTestPooledConnection( resc, "CHECKOUT" );
            else
          testPooledConnection( resc );
        }
                            connectionCustomizer.onCheckOut( physicalConnection, parentDataSourceIdentityToken );
                        }
                        catch (ClassCastException e)
                        {
                            throw SqlUtils.toSQLException("Cannot use a ConnectionCustomizer with a non-c3p0 PooledConnection." +
                                            " PooledConnection: " + resc + 
                                            "; ConnectionPoolDataSource: " + cpds.getClass().getName(), e);
                        }
                        finally
                        { unmarkPhysicalConnectionInUse(physicalConnection); }
                    }
        else
        {
      if ( testConnectionOnCheckout )
          {
        PooledConnection pc = (PooledConnection) resc;
        try
        {
            waitMarkPooledConnectionInUse( pc );
            assert !Boolean.FALSE.equals(pooledConnectionInUse( pc )); //null or true are okay


            if ( Debug.DEBUG && logger.isLoggable( MLevel.FINER ) )
          finerLoggingTestPooledConnection( pc, "CHECKOUT" );
            else
          testPooledConnection( pc );
        }
        finally
        { 
            unmarkPooledConnectionInUse(pc); 
        }
          }
        }
                }


    // TODO: refactor this by putting the connectionCustomizer if logic inside the (currently repeated) logic
                public void refurbishResourceOnCheckin( Object resc ) throws Exception
                {
                    if ( connectionCustomizer != null )
                    {
                        Connection physicalConnection = null;
                        try
                        { 
                            physicalConnection =  ((AbstractC3P0PooledConnection) resc).getPhysicalConnection();
                            
          // so by the time we are checked in, all marked-for-destruction statements should be closed.
                            waitMarkPhysicalConnectionInUse( physicalConnection );
                            connectionCustomizer.onCheckIn( physicalConnection, parentDataSourceIdentityToken );
                            SQLWarnings.logAndClearWarnings( physicalConnection );


          if ( testConnectionOnCheckin )
        { 
            if ( Debug.DEBUG && logger.isLoggable( MLevel.FINER ) )
          finerLoggingTestPooledConnection( resc, "CHECKIN" );
            else
          testPooledConnection( resc );
        }


                        }
                        catch (ClassCastException e)
                        {
                            throw SqlUtils.toSQLException("Cannot use a ConnectionCustomizer with a non-c3p0 PooledConnection." +
                                            " PooledConnection: " + resc + 
                                            "; ConnectionPoolDataSource: " + cpds.getClass().getName(), e);
                        }
                        finally
                        { unmarkPhysicalConnectionInUse(physicalConnection); }
                    }
                    else
                    {
                        PooledConnection pc = (PooledConnection) resc;
                        Connection con = null;


                        try
                        {


          // so by the time we are checked in, all marked-for-destruction statements should be closed.
                            waitMarkPooledConnectionInUse( pc );
                            con = pc.getConnection();
                            SQLWarnings.logAndClearWarnings(con);


          if ( testConnectionOnCheckin )
        { 
            if ( Debug.DEBUG && logger.isLoggable( MLevel.FINER ) )
          finerLoggingTestPooledConnection( resc, con, "CHECKIN" );
            else
          testPooledConnection( resc, con );
        }


                        }
                        finally
                        {
                            // close the proxy Connection
                            ConnectionUtils.attemptClose(con);
                            
                            unmarkPooledConnectionInUse( pc );
                        }
                    }
                }


                public void refurbishIdleResource( Object resc ) throws Exception
                { 
        PooledConnection pc = (PooledConnection) resc;        
                    if ( Debug.DEBUG && logger.isLoggable( MLevel.FINER ) )
                        finerLoggingTestPooledConnection( resc, "IDLE CHECK" );
                    else
                        testPooledConnection( resc );
                }


                private void finerLoggingTestPooledConnection(Object resc, String testImpetus) throws Exception
    { finerLoggingTestPooledConnection( resc, null, testImpetus); }




                private void finerLoggingTestPooledConnection(Object resc, Connection proxyConn, String testImpetus) throws Exception
                {
                    logger.finer("Testing PooledConnection [" + resc + "] on " + testImpetus + ".");
                    try
                    {
                        testPooledConnection( resc, proxyConn );
                        logger.finer("Test of PooledConnection [" + resc + "] on " + testImpetus + " has SUCCEEDED.");
                    }
                    catch (Exception e)
                    {
                        logger.log(MLevel.FINER, "Test of PooledConnection [" + resc + "] on "+testImpetus+" has FAILED.", e);
                        e.fillInStackTrace();
                        throw e;
                    }
                }


                private void testPooledConnection(Object resc) throws Exception
    { testPooledConnection( resc, null ); }


                private void testPooledConnection(Object resc, Connection proxyConn) throws Exception
                { 
                    PooledConnection pc = (PooledConnection) resc;
        assert !Boolean.FALSE.equals(pooledConnectionInUse( pc )); //null or true are okay


                    Throwable[] throwableHolder = EMPTY_THROWABLE_HOLDER;
                    int status;
                    Connection openedConn = null;
                    Throwable rootCause = null;
                    try  
                    { 
      // No! Connection must be maked in use PRIOR TO Connection test
                        //waitMarkPooledConnectionInUse( pc ); 
                        
                        // if this is a c3p0 pooled-connection, let's get underneath the
                        // proxy wrapper, and test the physical connection sometimes. 
                        // this is faster, when the testQuery would not otherwise be cached,
                        // and it avoids a potential statusOnException() double-check by the
                        // PooledConnection implementation should the test query provoke an
                        // Exception
                        Connection testConn;
                        if (scache != null) //when there is a statement cache...
                        {
                            // if it's the slow, default query, faster to test the raw Connection 
                            if (testQuery == null && connectionTesterIsDefault && c3p0PooledConnections)
                                testConn = ((AbstractC3P0PooledConnection) pc).getPhysicalConnection();
                            else //test will likely be faster on the proxied Connection, because the test query is probably cached
                                testConn = (proxyConn == null ? (openedConn = pc.getConnection()) : proxyConn); 
                        }
                        else //where there's no statement cache, better to use the physical connection, if we can get it
                        {
                            if (c3p0PooledConnections)
                                testConn = ((AbstractC3P0PooledConnection) pc).getPhysicalConnection();
                            else    
                                testConn = (proxyConn == null ? (openedConn = pc.getConnection()) : proxyConn);
                        }


                        if ( testQuery == null )
                            status = connectionTester.activeCheckConnection( testConn );
                        else

View Full Code Here

Examples of javax.sql.PooledConnection

    public PooledConnection checkoutPooledConnection() throws SQLException
    { 
        //System.err.println(this + " -- CHECKOUT");
        try 
      { 
    PooledConnection pc = (PooledConnection) this.checkoutAndMarkConnectionInUse(); 
    pc.addConnectionEventListener( cl );
    return pc;
      }
        catch (TimeoutException e)
        { throw SqlUtils.toSQLException("An attempt by a client to checkout a Connection has timed out.", e); }
        catch (CannotAcquireResourceException e)

View Full Code Here

Examples of javax.sql.PooledConnection


                final boolean connectionTesterIsDefault = (connectionTester instanceof DefaultConnectionTester);
 
                public Object acquireResource() throws Exception
                { 
                    PooledConnection out;


                    if ( connectionCustomizer == null)
                    {
                        out = (auth.equals( C3P0ImplUtils.NULL_AUTH ) ?
                               cpds.getPooledConnection() :
                               cpds.getPooledConnection( auth.getUser(), 
                                                         auth.getPassword() ) );
                    }
                    else
                    {
                        try
                        { 
                            WrapperConnectionPoolDataSourceBase wcpds = (WrapperConnectionPoolDataSourceBase) cpds;


                            out = (auth.equals( C3P0ImplUtils.NULL_AUTH ) ?
                                   wcpds.getPooledConnection( connectionCustomizer, parentDataSourceIdentityToken ) :
                                   wcpds.getPooledConnection( auth.getUser(), 
                                                              auth.getPassword(),
                                                              connectionCustomizer, parentDataSourceIdentityToken ) );
                        }
                        catch (ClassCastException e)
                        {
                            throw SqlUtils.toSQLException("Cannot use a ConnectionCustomizer with a non-c3p0 ConnectionPoolDataSource." +
                                            " ConnectionPoolDataSource: " + cpds.getClass().getName(), e);
                        }
                    }


                    //connectionCounter.increment(); 
                    //totalOpenedCounter.increment();


                    try
                    {
                        if (scache != null)
                        {
                            if (c3p0PooledConnections)
                                ((AbstractC3P0PooledConnection) out).initStatementCache(scache);
                            else
                            {
                                // System.err.print("Warning! StatementPooling not ");
                                // System.err.print("implemented for external (non-c3p0) ");
                                // System.err.println("ConnectionPoolDataSources.");


                                logger.warning("StatementPooling not " +
                                                "implemented for external (non-c3p0) " +
                                "ConnectionPoolDataSources.");
                            }
                        }
                        
                        // log and clear any SQLWarnings present upon acquisition
                        Connection con = null;
                        try
                        {
                            waitMarkPooledConnectionInUse(out);
                            con = out.getConnection();
                            SQLWarnings.logAndClearWarnings( con );
                        }
                        finally
                        {
                            //invalidate the proxy Connection

View Full Code Here

0 1 2 3 4 5

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.