Java ProtocolConnection类代码示例

import org.postgresql.core.ProtocolConnection; //导入依赖的package包/类
private void receiveRFQ() throws IOException {
    if (pgStream.ReceiveInteger4() != 5)
        throw new IOException("unexpected length of ReadyForQuery message");

    char tStatus = (char)pgStream.ReceiveChar();
    if (logger.logDebug())
        logger.debug(" <=BE ReadyForQuery(" + tStatus + ")");

    // Update connection state.
    switch (tStatus)
    {
    case 'I':
        protoConnection.setTransactionState(ProtocolConnection.TRANSACTION_IDLE);
        break;
    case 'T':
        protoConnection.setTransactionState(ProtocolConnection.TRANSACTION_OPEN);
        break;
    case 'E':
        protoConnection.setTransactionState(ProtocolConnection.TRANSACTION_FAILED);
        break;
    default:
        throw new IOException("unexpected transaction state in ReadyForQuery message: " + (int)tStatus);
    }
}
 

import org.postgresql.core.ProtocolConnection; //导入依赖的package包/类
public synchronized void processNotifies() throws SQLException {
    lock.lock();
    try {
        // Asynchronous notifies only arrive when we are not in a transaction
        if (protoConnection.getTransactionState() != ProtocolConnection.TRANSACTION_IDLE)
            return;

        try {
            while (pgStream.hasMessagePending()) {
                int c = pgStream.ReceiveChar();
                switch (c) {
                case 'A':  // Asynchronous Notify
                    receiveAsyncNotify();
                    break;
                case 'E':  // Error Message
                    throw receiveErrorMessage();
                    // break;
                case 'N':  // Error Notification
                    protoConnection.addWarning(receiveNotification());
                    break;
                default:
                    throw new PSQLException(GT.tr("Unknown Response Type {0}.", (char) c), PSQLState.CONNECTION_FAILURE);
                }
            }
        } catch (IOException ioe) {
            throw new PSQLException(GT.tr("An I/O error occurred while sending to the backend."), PSQLState.CONNECTION_FAILURE, ioe);
        }
    } finally {
        lock.unlock();
    }
}
 

import org.postgresql.core.ProtocolConnection; //导入依赖的package包/类
/**
 * Preconditions:
 * 1. xid must be in prepared state in the server
 *
 * Implementation deficiency preconditions:
 * 1. Connection must be in idle state
 * 
 * Postconditions:
 * 1. Transaction is committed
 */
private void commitPrepared(Xid xid) throws XAException {
    try
    {
        // Check preconditions. The connection mustn't be used for another
        // other XA or local transaction, or the COMMIT PREPARED command
        // would mess it up.
        if (state != STATE_IDLE || conn.getTransactionState() != ProtocolConnection.TRANSACTION_IDLE)
            throw new PGXAException(GT.tr("Not implemented: 2nd phase commit must be issued using an idle connection"),
                                    XAException.XAER_RMERR);

        String s = RecoveredXid.xidToString(xid);

        localAutoCommitMode = conn.getAutoCommit();
        conn.setAutoCommit(true);
        Statement stmt = conn.createStatement();
        try
        {
            stmt.executeUpdate("COMMIT PREPARED '" + s + "'");
        }
        finally
        {
            stmt.close();
            conn.setAutoCommit(localAutoCommitMode);
        }
    }
    catch (SQLException ex)
    {
        throw new PGXAException(GT.tr("Error committing prepared transaction"), ex, XAException.XAER_RMERR);
    }
}
 

import org.postgresql.core.ProtocolConnection; //导入依赖的package包/类
private void interpretCommandStatus(String status, ResultHandler handler) throws IOException {
    int update_count = 0;
    long insert_oid = 0;

    if (status.equals("BEGIN"))
        protoConnection.setTransactionState(ProtocolConnection.TRANSACTION_OPEN);
    else if (status.equals("COMMIT") || status.equals("ROLLBACK"))
        protoConnection.setTransactionState(ProtocolConnection.TRANSACTION_IDLE);
    else if (status.startsWith("INSERT") || status.startsWith("UPDATE") || status.startsWith("DELETE") || status.startsWith("MOVE"))
    {
        try
        {
            long updates = Long.parseLong(status.substring(1 + status.lastIndexOf(' ')));

            // deal with situations where the update modifies more than 2^32 rows
            if ( updates > Integer.MAX_VALUE )
                update_count = Statement.SUCCESS_NO_INFO;
            else
                update_count = (int)updates;
            
            if (status.startsWith("INSERT"))
                insert_oid = Long.parseLong(status.substring(1 + status.indexOf(' '),
                                            status.lastIndexOf(' ')));
        }
        catch (NumberFormatException nfe)
        {
            handler.handleError(new PSQLException(GT.tr("Unable to interpret the update count in command completion tag: {0}.", status), PSQLState.CONNECTION_FAILURE));
            return ;
        }
    }

    handler.handleCommandStatus(status, update_count, insert_oid);
}
 

import org.postgresql.core.ProtocolConnection; //导入依赖的package包/类
private ResultHandler sendQueryPreamble(final ResultHandler delegateHandler, int flags) throws IOException {
    // First, send CloseStatements for finalized SimpleQueries that had statement names assigned.
    processDeadParsedQueries();
    processDeadPortals();

    // Send BEGIN on first statement in transaction.
    if ((flags & QueryExecutor.QUERY_SUPPRESS_BEGIN) != 0 ||
            protoConnection.getTransactionState() != ProtocolConnection.TRANSACTION_IDLE)
        return delegateHandler;

    int beginFlags = QueryExecutor.QUERY_NO_METADATA;
    if ((flags & QueryExecutor.QUERY_ONESHOT) != 0) {
      beginFlags |= QueryExecutor.QUERY_ONESHOT;
    }
    sendOneQuery(beginTransactionQuery, SimpleQuery.NO_PARAMETERS, 0, 0, beginFlags);

    // Insert a handler that intercepts the BEGIN.
    return new ResultHandler() {
               private boolean sawBegin = false;

               public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
                   if (sawBegin)
                       delegateHandler.handleResultRows(fromQuery, fields, tuples, cursor);
               }

               public void handleCommandStatus(String status, int updateCount, long insertOID) {
                   if (!sawBegin)
                   {
                       sawBegin = true;
                       if (!status.equals("BEGIN"))
                           handleError(new PSQLException(GT.tr("Expected command status BEGIN, got {0}.", status),
                                                         PSQLState.PROTOCOL_VIOLATION));
                   }
                   else
                   {
                       delegateHandler.handleCommandStatus(status, updateCount, insertOID);
                   }
               }

               public void handleWarning(SQLWarning warning) {
                   delegateHandler.handleWarning(warning);
               }

               public void handleError(SQLException error) {
                   delegateHandler.handleError(error);
               }

               public void handleCompletion() throws SQLException{
                   delegateHandler.handleCompletion();
               }
           };
}
 

import org.postgresql.core.ProtocolConnection; //导入依赖的package包/类
public void doSubprotocolBegin() throws SQLException {
    if (protoConnection.getTransactionState() == ProtocolConnection.TRANSACTION_IDLE)
    {

        if (logger.logDebug())
            logger.debug("Issuing BEGIN before fastpath or copy call.");

        ResultHandler handler = new ResultHandler() {
                                    private boolean sawBegin = false;
                                    private SQLException sqle = null;

                                    public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
                                    }

                                    public void handleCommandStatus(String status, int updateCount, long insertOID) {
                                        if (!sawBegin)
                                        {
                                            if (!status.equals("BEGIN"))
                                                handleError(new PSQLException(GT.tr("Expected command status BEGIN, got {0}.", status),
                                                                              PSQLState.PROTOCOL_VIOLATION));
                                            sawBegin = true;
                                        }
                                        else
                                        {
                                            handleError(new PSQLException(GT.tr("Unexpected command status: {0}.", status),
                                                                          PSQLState.PROTOCOL_VIOLATION));
                                        }
                                    }

                                    public void handleWarning(SQLWarning warning) {
                                        // we don't want to ignore warnings and it would be tricky
                                        // to chain them back to the connection, so since we don't
                                        // expect to get them in the first place, we just consider
                                        // them errors.
                                        handleError(warning);
                                    }

                                    public void handleError(SQLException error) {
                                        if (sqle == null)
                                        {
                                            sqle = error;
                                        }
                                        else
                                        {
                                            sqle.setNextException(error);
                                        }
                                    }

                                    public void handleCompletion() throws SQLException{
                                        if (sqle != null)
                                            throw sqle;
                                    }
                                };

        try
        {
            sendOneQuery(beginTransactionQuery, SimpleQuery.NO_PARAMETERS, 0, 0, QueryExecutor.QUERY_NO_METADATA);
            sendSync();
            processResults(handler, 0);
            estimatedReceiveBufferBytes = 0;
        }
        catch (IOException ioe)
        {
            throw new PSQLException(GT.tr("An I/O error occurred while sending to the backend."), PSQLState.CONNECTION_FAILURE, ioe);
        }
    }

}
 

import org.postgresql.core.ProtocolConnection; //导入依赖的package包/类
public void processNotifies() throws SQLException {
    lock.lock();
    try {
        waitOnLock();
        // Asynchronous notifies only arrive when we are not in a transaction
        if (protoConnection.getTransactionState() != ProtocolConnection.TRANSACTION_IDLE)
            return;

        try {
            while (pgStream.hasMessagePending()) {
                int c = pgStream.ReceiveChar();
                switch (c) {
                case 'A':  // Asynchronous Notify
                    receiveAsyncNotify();
                    break;
                case 'E':  // Error Response (response to pretty much everything; backend then skips until Sync)
                    throw receiveErrorResponse();
                    // break;
                case 'N':  // Notice Response (warnings / info)
                    SQLWarning warning = receiveNoticeResponse();
                    protoConnection.addWarning(warning);
                    break;
                default:
                    throw new PSQLException(GT.tr("Unknown Response Type {0}.", (char) c), PSQLState.CONNECTION_FAILURE);
                }
            }
        } catch (IOException ioe) {
            throw new PSQLException(GT.tr("An I/O error occurred while sending to the backend."), PSQLState.CONNECTION_FAILURE, ioe);
        }
    } finally {
        lock.unlock();
    }
}