Review: ReStore 1.10 (Object - Relational DB Interface) For Dolphin

I thought others might benefit from a hands on review of ReStore now that I
have used it on a real project.

ReStore 1.10 For Dolphin Review

What is ReStore?
============
ReStore is an object to relational database interface.  It allows you to
store and retrieve objects from a traditional relational database (such as
MS Access, SQL Server, etc.).  It is a commercial product available from
Solutions Software ( http://www.solutionsoft.co.uk/restore/ ) for Dolphin
Smalltalk.  I have no financial interest in the software; I am just a happy
user.

The Review:
=========
I purchased a copy of ReStore in July shortly after its release, and I have
been using it since.  I was initially impressed with its relative
transparency.  You add a class method to each class you want to make
persistent in order to define how it should be stored in the database.  Then
you write a simple method to open the ReStore database and connect it to a
DSN (it uses Dolphin's ODBC interface, and can be configured for different
SQL dialects).  The tables will automatically be created or modified as
needed.  If you add new persistent variables to a class ReStore will update
the tables for you when told to reconnect.  This makes it easy to use
ReStore as part of an incremental development process.  ReStore uses the
concept of a pseudo collection as its primary data retrieval mechanism.  You
tell it what class you want to look up and it returns an object that behaves
like a Smalltalk collection.  You can iterate over it with #do: or use some
of the more complex collections messages such as collect:, select:, detect:.
The key here is that it is not a real collection and does not retrieve the
objects until they are actually needed.  When it does retrieve the objects
it uses an SQL query based on parsing a normal Smalltalk block.  It is quite
transparent because you can treat it almost like a normal collection.  The
fact that it uses an SQL query improves the efficiency by offloading the
query work to the database and avoiding unnecessary object creation.  It
uses an object and precompiled statement cache to further improve
efficiency.

I have used ReStore on a project I might otherwise have used an MS Access
interface for.  The program needed to store a number of different kinds of
related records.  There seemed to be a natural composite relationship
amongst the records so I wanted to use an object oriented approach.  An
object database might seem like an obvious choice, however the client
preferred to have the data stored in a more accessible (for them) fashion.
They wanted us to use an MS Access database.  We managed to get approval
based on the fact that the data would reside in MS Access and the users
interface would be developed in Dolphin Smalltalk.  The program has about 16
persistent class groups; some tables had over 8,000 records in testing.
There is some very slight lag in the UI when it is retrieving a lot of data
for enhanced list views, which is to be expected.  ReStore feels very quick
when committing small amounts of data.  In my project I have an import
feature that can import quite a bit of data, obviously this takes longer to
commit to the database.  I developed a special dialog to encourage the user
to wait for the data to commit to the database after it is accepted.

Strong Points
==========
1. ReStore provides a very easy way of adding database persistence to an
object oriented application at a great price (~USD$150.00).  It would have
cost me far more than the price of the product for me to implement something
similar.
2. The data can be easily accessed from the relational database by different
tools.  The database structure is easy to figure out if you are familiar
with the object relationships.  The tables and fields use names based on
their Smalltalk counterparts.
3. Solution Software has provided absolutely outstanding support for this
product, often having a solution the next day after a problem report.  They
have even added fairly substantial features to the program at their users'
suggestion.  They definitely seem attentive to the needs of their users.
4. It accommodates the most important Smalltalk collections, even providing
for automatic ListModel wrapping, and various kinds of Dictionary keys.
5. There is a good web based manual, and an example application available to
demonstrate how to us it.
6. The user can avoid SQL.  I don't have anything against SQL, but not
having to code it and make sure it is precompiled (to achieve decent speed)
removes an entire layer from my design.  It is one less thing I have to deal
with.  I can concentrate on my business logic rather than data access code.
7. ReStore can be configured to work with different SQL dialects.  Right now
I am just using MS Access, however if my needs grow I think it will be easy
to switch to MS SQL server.
8. ReStore supports multiple concurrent users, and provides tools for
conflict resolution.
9. ReStore provides a TransactionalDialog class that automates transactional
handling for Dialogs.
10. As is the tradition in Smalltalk full source code is provided.
11. Most small patches were sent to me as extension packages or code I could
file in.  This made upgrading much easier than having to uninstall and
reinstall the complete package.

Potential Weak Points
================
1. ReStore wants to create its own database structure.  This is good because
it makes it easy to use, however it will prevent someone from easily using a
predetermined database structure.
2. Currently persistent instance variables and collections can only contain
descendants of a common class.  It cannot accommodate values of unrelated
classes.  I have not found this to be a problem in practice yet, but it is
something to be aware of.
3. Some slight care is needed to avoid having the UI try to update the
display while changes are committing.  In practice this is not often a
problem, and when it is adding a small delay can easily solve it.
4. A separate database engine (such as MS Access, SQL Server, Oracle, MySQL
etc.) is required.  This is not a big problem because (I believe) the Jet
engine (MS Access engine) can be included in an installation.  It is also
installed by default (I think) in Windows 98 and above.
5. You have to create a DSN pointing to the database (for ODBC).  Actually
this requirement can be eliminated with some creative hacking in the Dolphin
DBConnection class.  However it is not hard to create a DSN with a good
installation program (Look at the free Inno Setup with ISTool GUI).

Conclusion
========
I really like ReStore and highly recommend it.  It has improved my
productivity by providing a natural Smalltalk-feeling database storage and
retrieval system.  It lets me focus on Objects, not database interface code.
They have a demo and lots of information at their site
http://www.solutionsoft.co.uk/restore/ .

Chris