[VPM] Rosetta v0.07 is uploaded

[Darren Duncan]

FYI, I have just uploaded Rosetta v0.07 to CPAN.  This was mainly a documentation update, with lots of updates.  For an example, I have included a completely rewritten framework Abstract in the body of this letter, so you can get a much clearer idea what the framework does and does not do from before.  And there were numerous changes.  Have a good day. -- Darren Duncan

---------------------------------------------

Rosetta is a comprehensive framework for database-using applications of any
size or function that allows them to be easily portable across multiple
database implementations because any proprietary details of each are abstracted
away.  At the same time, it is designed to be fast and efficient.  Applications
use Rosetta as a virtual embedded database, whose API is called the "Rosetta
Native Interface" or "RNI", and whose feature set is an opaque normalized
superset of all common database feature sets.  The feature superset includes
both data manipulation (with multi-table selects and updates plus subqueries or
stored procedure calls) and schema manipulation (tables, views, procedures).
Rosetta is designed to work equally well with both embedded and client-server
databases; in the latter case, it is the client.

The RNI is implemented using mainly a "Command" design pattern, meaning that it
has few real functions or methods, but those use objects as input and output,
which are flexible enough to define any task or result.  The RNI is verbose and
intended to provide non-ambiguous structured definitions of all tasks, so that
the results of executing them are easy to predict; the definitions are
multi-dimensional data structures (or objects) having atomic values (which also
have native data type formats).  Rosetta has this as an advantage over other
database abstractions that use serialized strings like SQL (such as ODBC/JDBC),
because each database has its own SQL dialect, and applications using them must
be coded differently for each one.  Rosetta is especially suited for
data-driven applications, since the composite scalar values in their data
dictionaries can often be copied directly to RNI structures, saving
applications the tedious work of generating SQL themselves.  Rosetta also
provides native internationalization support, for example allowing system
messages to be in multiple user languages simultaneously.

Rosetta makes it easy to layer alternative APIs on top of RNI, so that you can
simplify or customize it to your specific needs.  As practical examples of
this, there are several emulators provided for common existing database APIs
(such as ODBC/JDBC), so that most applications can simply use Rosetta as a
hot-swappable replacement for them; you do not have to "learn yet another
language" or re-code your application in order for it to just work with more
databases.  While the Rosetta core must always be embedded in an application to
be used, an extension is available that will allow it to be used in a
client-server arrangement instead (as ODBC does), where the server is a proxy
for the client; the client is embedded in the main application, and it talks to
the server in network-serialized RNI, which then translates the request into
native database actions.  Some utilities built on Rosetta are also available,
for such tasks as cloning or backing up a database (schema and/or data; this
includes scanning the database to make a data dictionary), or editing one
through a web interface (like PHPPgAdmin or PHPMyAdmin but for any RDBMS).

Rosetta is not a complete database by itself and you need to separately have an
actual database to use it with.  (But there is a new embedded database
available, suited for small data sets, that was created just for Rosetta.)
Rosetta does not usually implement features that are missing in a database
being abstracted (such as foreign key constraints, transactional integrity, or
geographical data types), in order to give it an identical feature set to a
more capable database; Rosetta just allows for the features that do exist to be
called in an identical way.  A consequence of this is that your choice of
database implementation will indeed affect what features you have available;
your application will port without changes only to databases which support the
features that you use.  The RNI may not interface to every single feature of a
particular database (neglecting esoteric ones), so you can't use those features
with Rosetta (but support can be added).  Rosetta does not automate
installation of any separate database software or configure it (like a package
manager); you will have to do that yourself.