From: Volker Paepcke
Date: April 29 1999 7:14am
Subject: Re: transaction support
List-Archive: http://lists.mysql.com/mysql/2584
Message-Id: <199904290714.JAA06714@yavin.franken.de>
MIME-Version: 1.0
Content-Type: text/plain; charset=us-ascii

> On Tue, 27 Apr 1999 14:22:37 -0600, Sasha Pachev wrote:
> 
... stuff deleted
> 
> In general, it's just more work in the application to be traded off
> against the overhead [for all work] of having transaction support in
> the server. Same for referential integrity: It's work for the app to
> enforce it where needed, and work for the server to enforce it
> generally. The problem with doing it server side is that is slows down
> all the work that doesn't need transactions/referential integrity.
> 

I have another proposal for transaction support with mysql: Implement some
kind of middleware on the server side, which is doing all DB accesses. The
clients communicate via Corba with this thing and don't have to use any
SQL calls. Instead object oriented methods can be implemented in the server
which can be used by the clients. Because the server does all the DB 
accesses for himself, its more or less easy to implement transaction 
support here, depending on the programming language and platform used on 
the server. I've implemented a small Java Server with JDBC access to the 
mysql server half a year ago. There are a couple of Java clients and C++
clients who access the server via Corba. The performance is great despite the
overhead of the additional middleware layer. This is because the server is
multithreaded, like the mysql server, and i'm using a customizable number 
of parallel connections between the server and mysql. It's possible to
serve more clients with this technique too, because its not necessary to
create a connection to mysql for every client anymore. Another plus is the
less IO between the client and the server due to the prework, the server
can do on the data from the DB, before it is forwarded to the client. And
if you need to do heavy work on the server you can put it on an extra 
machine, so this solution scales very good depending on the application.

What do you think about this? I've made very good experiences with this
implementation so far. But It's a pity that I can't use Enterprise 
JavaBeans technology, because this depends on transaction support in the
DB itself. The problem that remains is, that I can't use a big TP-Monitor
from componies like BEA, IBM, Gemstone and so on with mysql right now.
So I have to write it myself...


bye
Volker