Package org.postgresql.xa

# Class PGXAConnection

java.lang.Object
org.postgresql.ds.PGPooledConnection
org.postgresql.xa.PGXAConnection

All Implemented Interfaces:
  `PooledConnection`, `XAConnection`, `XAResource`

public class PGXAConnection extends PGPooledConnection implements XAConnection, XAResource
The PostgreSQL implementation of `XAResource`.

This implementation doesn't support transaction interleaving (see JTA specification, section 3.4.4) and suspend/resume.

Two-phase commit requires PostgreSQL server version 8.1 or higher.

- ## Field Summary

  ### Fields inherited from interface javax.transaction.xa.XAResource

  `TMENDRSCAN, TMFAIL, TMJOIN, TMNOFLAGS, TMONEPHASE, TMRESUME, TMSTARTRSCAN, TMSUCCESS, TMSUSPEND, XA_OK, XA_RDONLY`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `PGXAConnection(BaseConnection conn)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `commit(Xid xid, boolean onePhase)`
  `void`
  `end(Xid xid, int flags)`
  Preconditions: Flags is one of TMSUCCESS, TMFAIL, TMSUSPEND xid != null Connection is associated with transaction xid
  `void`
  `forget(Xid xid)`
  Does nothing, since we don't do heuristics.
  `Connection`
  `getConnection()`
  XAConnection interface.
  `int`
  `getTransactionTimeout()`
  We don't do transaction timeouts.
  `XAResource`
  `getXAResource()`
  `boolean`
  `isSameRM(XAResource xares)`
  `int`
  `prepare(Xid xid)`
  Prepares transaction.
  `Xid[]`
  `recover(int flag)`
  Recovers transaction.
  `void`
  `rollback(Xid xid)`
  Preconditions: xid is known to the RM or it's in prepared state
  `boolean`
  `setTransactionTimeout(int seconds)`
  We don't do transaction timeouts.
  `void`
  `start(Xid xid, int flags)`
  Preconditions: Flags must be one of TMNOFLAGS, TMRESUME or TMJOIN xid != null Connection must not be associated with a transaction The TM hasn't seen the xid before

  ### Methods inherited from class org.postgresql.ds.PGPooledConnection

  `addConnectionEventListener, addStatementEventListener, close, createConnectionEvent, removeConnectionEventListener, removeStatementEventListener`

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

  ### Methods inherited from interface javax.sql.PooledConnection

  `addConnectionEventListener, addStatementEventListener, close, removeConnectionEventListener, removeStatementEventListener`

- ## Constructor Details

  - ### PGXAConnection

    public PGXAConnection(BaseConnection conn) throws SQLException
    Throws:
      `SQLException`

- ## Method Details

  - ### getConnection

    public Connection getConnection() throws SQLException
    XAConnection interface.
    Specified by:
      `getConnection` in interface `PooledConnection`
    Overrides:
      `getConnection` in class `PGPooledConnection`
    Throws:
      `SQLException`

  - ### getXAResource

    public XAResource getXAResource()
    Specified by:
      `getXAResource` in interface `XAConnection`

  - ### start

    public void start(Xid xid, int flags) throws XAException
    Preconditions:
    1. Flags must be one of TMNOFLAGS, TMRESUME or TMJOIN
    2. xid != null
    3. Connection must not be associated with a transaction
    4. The TM hasn't seen the xid before

    Implementation deficiency preconditions:

    1. TMRESUME not supported.
    2. If flags is TMJOIN, we must be in ended state, and xid must be the current transaction
    3. Unless flags is TMJOIN, previous transaction using the connection must be committed or prepared or rolled back

    Postconditions:

    1. Connection is associated with the transaction
    Specified by:
      `start` in interface `XAResource`
    Throws:
      `XAException`

  - ### end

    public void end(Xid xid, int flags) throws XAException
    Preconditions:
    1. Flags is one of TMSUCCESS, TMFAIL, TMSUSPEND
    2. xid != null
    3. Connection is associated with transaction xid

    Implementation deficiency preconditions:

    1. Flags is not TMSUSPEND

    Postconditions:

    1. Connection is disassociated from the transaction.
    Specified by:
      `end` in interface `XAResource`
    Throws:
      `XAException`

  - ### prepare

    public int prepare(Xid xid) throws XAException
    Prepares transaction. Preconditions:
    1. xid != null
    2. xid is in ended state

    Implementation deficiency preconditions:

    1. xid was associated with this connection

    Postconditions:

    1. Transaction is prepared
    Specified by:
      `prepare` in interface `XAResource`
    Throws:
      `XAException`

  - ### recover

    public Xid[] recover(int flag) throws XAException
    Recovers transaction. Preconditions:
    1. flag must be one of TMSTARTRSCAN, TMENDRSCAN, TMNOFLAGS or TMSTARTTRSCAN | TMENDRSCAN
    2. If flag isn't TMSTARTRSCAN or TMSTARTRSCAN | TMENDRSCAN, a recovery scan must be in progress

    Postconditions:

    1. list of prepared xids is returned
    Specified by:
      `recover` in interface `XAResource`
    Throws:
      `XAException`

  - ### rollback

    public void rollback(Xid xid) throws XAException
    Preconditions:
    1. xid is known to the RM or it's in prepared state

    Implementation deficiency preconditions:

    1. xid must be associated with this connection if it's not in prepared state.

    Postconditions:

    1. Transaction is rolled back and disassociated from connection
    Specified by:
      `rollback` in interface `XAResource`
    Throws:
      `XAException`

  - ### commit

    public void commit(Xid xid, boolean onePhase) throws XAException
    Specified by:
      `commit` in interface `XAResource`
    Throws:
      `XAException`

  - ### isSameRM

    public boolean isSameRM(XAResource xares) throws XAException
    Specified by:
      `isSameRM` in interface `XAResource`
    Throws:
      `XAException`

  - ### forget

    public void forget(Xid xid) throws XAException
    Does nothing, since we don't do heuristics.
    Specified by:
      `forget` in interface `XAResource`
    Throws:
      `XAException`

  - ### getTransactionTimeout

    public int getTransactionTimeout()
    We don't do transaction timeouts. Just returns 0.
    Specified by:
      `getTransactionTimeout` in interface `XAResource`

  - ### setTransactionTimeout

    public boolean setTransactionTimeout(int seconds)
    We don't do transaction timeouts. Returns false.
    Specified by:
      `setTransactionTimeout` in interface `XAResource`