>>> branch id: Branch Identifier. Every RM involved in the global
>>> transaction is given a *different* branch id.
>>
>> Hm, I am confused then -- the XA spec definitely talks about
enlisting
>> multiple RMs in a single transaction branch.
>>
>> Can you explain?
>
>I oversimplified a bit. The TM *can* enlist multiple threads of control
(=
>connection in JTA) to the same transaction branch. That's called
>"tightly-coupled threads", and they should then be treated as one
>local transaction in the RM. The calls will look like this:
>
>conn1.start(xid1, TMNOFLAGS);
>...
>conn2.start(xid1, TMJOIN);
>...
>conn1.end(xid1, TMSUCCESS);
>...
>conn2.end(xid1, TMSUCCESS);
>
>connX.prepare(xid1);
>connX.commit(xid1, false);
>
>conn1 and conn2 must share locks and see each others changes. They
>mustn't deadlock each other. The JDBC driver can implement this in a
very
>straight-forward way by using the same physical connection for both
conn1
>and conn2. Note that there's only one prepare, and it can be issued
using
>any connection.

In your example above couldn't conn1 and conn2 be running in two
different JVMs? And thus your statement that 'the JDBC driver can
implement this in a very straight-forward way by using the same physical
connection' would not be true. I can't see a way for two JVMs (possibly
on different client machines even) to share the same physical
connection.

--Barry




---------------------------(end of broadcast)---------------------------
TIP 3: if posting/reading through Usenet, please send an appropriate
subscribe-nomail command to majordomo@postgresql.org so that your
message can get through to the mailing list cleanly

On Fri, 1 Jul 2005, Barry Lind wrote:

>> I oversimplified a bit. The TM *can* enlist multiple threads of control
>> (= connection in JTA) to the same transaction branch. That's called
>> "tightly-coupled threads", and they should then be treated as one
>> local transaction in the RM. The calls will look like this:
>>
>> conn1.start(xid1, TMNOFLAGS);
>> ...
>> conn2.start(xid1, TMJOIN);
>> ...
>> conn1.end(xid1, TMSUCCESS);
>> ...
>> conn2.end(xid1, TMSUCCESS);
>>
>> connX.prepare(xid1);
>> connX.commit(xid1, false);
>>
>> conn1 and conn2 must share locks and see each others changes. They
>> mustn't deadlock each other. The JDBC driver can implement this in a
> very
>> straight-forward way by using the same physical connection for both
> conn1
>> and conn2. Note that there's only one prepare, and it can be issued
> using
>> any connection.
>
> In your example above couldn't conn1 and conn2 be running in two
> different JVMs? And thus your statement that 'the JDBC driver can
> implement this in a very straight-forward way by using the same physical
> connection' would not be true. I can't see a way for two JVMs (possibly
> on different client machines even) to share the same physical
> connection.

I can't immediately think of a reason why they couldn't run in two
different JVMs, but I also can't think of a reason why anyone would want
to do that. Can you give a use case for that?

Also, it would require an application server that would support that, and
I don't think there is any.

- Heikki

---------------------------(end of broadcast)---------------------------
TIP 7: don't forget to increase your free space map settings