Does anyone know of a system for CL which provides transactions (in
the proper databasy sense, or something close to that) but does not
bundle in persistency &c. I'm aware of PLOB and peripherally of
allegrostore which I think do both transactions & persistency, but I'd
like something which does just the transactional part. It occured to
me that it ought to be possible to do this with some MOPpy thing &
CLOS, but I haven't thought about it very far so far.
This is a very vague specification of what I'm interested in, sorry.
I'm really just after any pointers for anything that does anything in
this kind of area.
--tim
* "Tim" == Tim Bradshaw <···@tfeb.org> writes:
Tim> Does anyone know of a system for CL which provides transactions
Tim> (in the proper databasy sense, or something close to that) but
Tim> does not bundle in persistency &c.
Not sure if that is what you are looking for, but Pierre Mai's MaiSQL
contains implementation of WITH-TRANSACTION macro. However, it doesn't
relies on DBMS transaction support mechanisms but provides its own
instead.
Since MaiSQL interface mimics the one of CommonSQL, probably Xanalys'
implementation ships with a similar feature.
--
Eugene
Eugene Zaikonnikov <······@cit.org.by> writes:
> * "Tim" == Tim Bradshaw <···@tfeb.org> writes:
>
> Tim> Does anyone know of a system for CL which provides transactions
> Tim> (in the proper databasy sense, or something close to that) but
> Tim> does not bundle in persistency &c.
>
> Not sure if that is what you are looking for, but Pierre Mai's MaiSQL
> contains implementation of WITH-TRANSACTION macro. However, it doesn't
> relies on DBMS transaction support mechanisms but provides its own
> instead.
As the author of said package I'm somewhat surprised, because I
specifically didn't write any WITH-TRANSACTION macro, because at the
time I couldn't convince myself that I had a firm grasp on the
interaction of possibly nested with-transaction invocations and
conditions with the underlying SQL transaction mechanisms.
Furthermore the originally supported backend -- MySQL -- didn't have
any transaction mechanisms at the time...
You are probably thinking of the UncommonSQL package the people at
OnShore developed, which is based on MaiSQL, but contains a much more
complete implementation of CommonSQL, including a with-transaction
macro, though this does make use of the DBMS transaction support
mechanisms. Indeed I can't imagine an easy way to provide ACID
transactions in the face of DBMS interfacing that doesn't use the
underlying transaction mechanisms...
But on the whole it seems to me that what Tim is probably looking for
is a general-purpose MOP-based transaction system for CLOS slot
accesses, so none of the DB interfacing stuff would fit the bill...
Regs, Pierre.
--
Pierre R. Mai <····@acm.org> http://www.pmsf.de/pmai/
The most likely way for the world to be destroyed, most experts agree,
is by accident. That's where we come in; we're computer professionals.
We cause accidents. -- Nathaniel Borenstein
* "Pierre" == Pierre R Mai <····@acm.org> writes:
[On with-transaction defined in MaiSQL]
Pierre> As the author of said package I'm somewhat surprised, because
Pierre> I specifically didn't write any WITH-TRANSACTION macro,
Ouch...
Pierre> You are probably thinking of the UncommonSQL package the
Pierre> people at OnShore developed, which is based on MaiSQL, but
Pierre> contains a much more complete implementation of CommonSQL,
Pierre> including a with-transaction macro, though this does make use
Pierre> of the DBMS transaction support mechanisms.
Right, it is defined in UncommonSQL; but since MaiSQL reference
mentions the macro when describing MAISQL-SQL-ERROR condition I
supposed that it is implemented within your package (I haven't the
original MaiSQL handy).
Pierre> Indeed I can't imagine an easy way to provide ACID
Pierre> transactions in the face of DBMS interfacing that doesn't use
Pierre> the underlying transaction mechanisms...
At a quick glance, I hadn't found any DBMS-specific things
there. After a steady look, however, it seems that WITH-TRANSACTIONS
there is in a rudimentary form (basically it handles nesting counters)
and doesn't handles transactions in the stricter sense.
Certainly I should check it myself before posting. Sorry for
confusion.
--
Eugene
Eugene Zaikonnikov <······@cit.org.by> writes:
> Pierre> You are probably thinking of the UncommonSQL package the
> Pierre> people at OnShore developed, which is based on MaiSQL, but
> Pierre> contains a much more complete implementation of CommonSQL,
> Pierre> including a with-transaction macro, though this does make use
> Pierre> of the DBMS transaction support mechanisms.
>
> Right, it is defined in UncommonSQL; but since MaiSQL reference
> mentions the macro when describing MAISQL-SQL-ERROR condition I
> supposed that it is implemented within your package (I haven't the
> original MaiSQL handy).
Oops, yes that could be termed a documentation bug in MaiSQL. Thanks
for pointing that out.
Regs, Pierre.
--
Pierre R. Mai <····@acm.org> http://www.pmsf.de/pmai/
The most likely way for the world to be destroyed, most experts agree,
is by accident. That's where we come in; we're computer professionals.
We cause accidents. -- Nathaniel Borenstein
"Pierre R. Mai" <····@acm.org> writes:
> But on the whole it seems to me that what Tim is probably looking for
> is a general-purpose MOP-based transaction system for CLOS slot
> accesses, so none of the DB interfacing stuff would fit the bill...
>
Yes, that's kind of right. I can almost see how to do it, but not
quite and I suspect it's very fiddly to get right as well.
--tim
In article <···············@tfeb.org>, Tim Bradshaw <···@tfeb.org>
wrote:
> Does anyone know of a system for CL which provides transactions (in
> the proper databasy sense, or something close to that) but does not
> bundle in persistency &c. I'm aware of PLOB and peripherally of
> allegrostore which I think do both transactions & persistency, but I'd
> like something which does just the transactional part. It occured to
> me that it ought to be possible to do this with some MOPpy thing &
> CLOS, but I haven't thought about it very far so far.
>
> This is a very vague specification of what I'm interested in, sorry.
> I'm really just after any pointers for anything that does anything in
> this kind of area.
>
> --tim
Don't know if anything of this is interesting for you:
"Camelot and Avalon: A Distributed Transaction Facility", J.L. Eppinger et
al, Morgan Kaufmann 1990.
Avalon/Common LISP - Prototype only. "Reliable Distributed Computing with
Avalon/Common LISP", S.M. Clamen et al, CMU-CS-89-186 and Proc Intl Conf on
Computer Languages, Mar 1990.
http://www.sdl.sri.com/dsa/publis.html
F. Gilham and D. Shih, "SDTP---A Multilevel-Secure Distributed Transaction
Processing System", Lisp Users Group Meeting, San Francisco, CA,
October 1999.
AP5
http://www.ap5.com/
AP5 extends Common Lisp with relations, operations on relations, consistency rules, and automation
rules. Operations and rules specify the semantics of programs. Efficiency details are declared via
annotations.
--
Rainer Joswig, Hamburg, Germany
Email: ·············@corporate-world.lisp.de
Web: http://corporate-world.lisp.de/
On 20 Nov 2000 16:46:05 +0000, Tim Bradshaw <···@tfeb.org> wrote:
> Does anyone know of a system for CL which provides transactions (in
> the proper databasy sense, or something close to that) but does not
> bundle in persistency &c. I'm aware of PLOB and peripherally of
May I suggest as a brainstorming aid the following series of papers on the
PCLOS persistent object database?
"A Flexible Implementation of CLOS Persistence"
Andreas Paepcke
OOPSLA '88 Proceedings
"PCLOS: A Critical Review"
Andreas Paepcke
OOPSLA '89 Proceedings
"PCLOS: Stress Testing CLOS - Experiencing the Metaobject Protocol"
Andreas Paepcke
ECOOP/OPPSLA '90 Proceedings
Although the system does support persistency, which you are not interested
in, it is based on the MOP and it addresses database transactions.
Paolo
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/