2004-09-09 Darren Duncan <perl@DarrenDuncan.net>
* Release 0.35.
* New code file versions are: Rosetta.pm v0.35, Rosetta/L/en.pm v0.10,
Validator.pm v0.05, and Validator/L/en.pm v0.04.
* Updated all versioned *.pm files to use the modern syntax "our $VERSION =
..." instead of "use vars qw($VERSION); $VERSION = ...".
* Updated external dependencies on Locale::KeyedText to v0.07 and on
SQL::SyntaxModel to v0.41.
* Changed the only reference on the SSM 'command' Node attribute
'command_arg_1', in Dispatcher.prepare_cmd_db_open(), to a reference on
that Node's child 'command_arg' Node.
* Renamed the only SSM call, in Interface._validate_ssm_node(), on
test_deferrable_constraints() to assert_deferrable_constraints().
* Renamed all references of "bind variables" to "host parameters", since
that is the official name for them in the SQL-2003 standard.
* A few minor updates in Framework.pod regarding database product versions.
2004-08-19 Darren Duncan <perl@DarrenDuncan.net>
* Release 0.34.
* New code file versions are: Rosetta.pm v0.34, Rosetta/L/en.pm v0.09, and
Validator.pm v0.04. (Validator/L/en.pm was not changed at all.)
* From now on, any modules that have 'Rosetta' as an explicit dependency
will also have implicit dependencies on the same versions of
[SQL::SyntaxModel, Locale::KeyedText] that Rosetta explicitly depends on;
the explicit dependencies on those two modules are now gone. If either of
the two modules are updated and a Rosetta-using module requires a newer
version, then that module should simply update its requirement to a version
of Rosetta that itself requires the implicit dependency.
* Updated all Rosetta.pm functions (and corresponding Rosetta/L/en.pm user
text) which invoke an Engine method so that, when they display any error
results (thrown misc exceptions or bad output), then the name of the
offending Engine class is displayed in the user text, for easier tracking
of problems.
* Added new Interface.get_root_interface() method and corresponding "root
interface" Interface property which provides a convenient short-cut to
access the root Application of an Intf's Interface tree. This property is
meant to make the module faster by avoiding a lot of frequent recursive
get_parent_interface() calls, which it is conceptually the same as.
* Added a couple of "bad result" tests to both prepare() and execute(), and
renamed the single existing one; made corresponding additions or updates to
Rosetta/L/en.pm. The first added test makes sure the Interface object
returned by those methods is in the same Intf tree as the invoked-on object
(an Engine could create a new tree if it wanted and return a piece of that,
a no-no). The second added test makes sure that the "Interface type" of
the returned Interface is correct, within reason (it is thorough for
prepare() as the tests are simple, but for execute() it's less so).
* Note that this release should be fully backwards compatible with any code
written for the previous release.
2004-08-16 Darren Duncan <perl@DarrenDuncan.net>
* Release 0.33.
* From now on, Rosetta and its primary distribution will have identical
version/release numbers, to help avoid public confusion as to which
distribution releases contain which Rosetta versions. This distribution's
Makefile.pl now uses "VERSION_FROM => 'lib/Rosetta.pm'" rather than
"VERSION => N". As such, Rosetta.pm will always have its own version
number incremented for any distribution changes, even if the changes are
otherwise entirely in other files. With this first such release,
Rosetta.pm is now at v0.33, up from v0.16 in the previous release.
* Other new code file versions are: lib/Rosetta/L/en.pm v0.08,
lib/Rosetta/Validator.pm v0.03, and lib/Rosetta/Validator/L/en.pm v0.03.
* Updated external dependencies on SQL::SyntaxModel to v0.38.
* Changed the first line of every file's COPYRIGHT AND LICENSE from "...
Rosetta database abstraction framework" to "... Rosetta database
portability library". Changed the NAME of Rosetta.pm from "Framework for
RDBMS-generic apps and schemas" to "Rigorous database portability". The
ReadMe file got a similar update to its main heading. Minor corresponding
updates to other documentation. These changes better reflect the current
state of the distribution, which contains just one important module, and
not a whole framework; the changes better reflect what is the purpose of
the module.
* Added new distinct RNI feature named TRAN_ROLLBACK_ON_DEATH, so an Engine
can declare what its implementing data storage product will do with
transactions left incomplete by a database process death or hardware
failure or severed connection from the Perl process (by Perl death or
network failure); the feature refers to a behaviour that is outside the
control of the Rosetta Engine module itself (which always tries to
explicitly rollback on disconnect if given the chance).
* The 'Row' Interface type no longer exists on its own; it has been rolled
into 'Literal', which was already a generic flexible type. In addition,
'Literal' Intfs can now be direct children of 'Application' Intfs; such is
now what you get when issuing commands like 'DB_LIST' against an App Intf.
* The "throw errors" Rosetta::Interface property no longer exists, nor does
its throw_errors() accessor method. Rosetta will now explcitly throw
object exceptions under every error condition, including errors raised
during prepare() and execute(); the option to have errors returned instead
no longer exists. As a result, many Rosetta.pm functions now have simpler
internal code (and user code). Corresponding updates were made to the
SYNOPSIS and SYNTAX POD. Also changed any code using "my $foo = undef;
eval { $foo = ... };" to instead use "my $foo = eval { return( ... ) };".
* Overhauled the way that the Rosetta::Dispatcher class was used so that
the Rosetta.pm code is now simpler, faster, easier to understand, and less
prone to errors. Now the root Rosetta::Dispatcher Engine object is always
created implicitly at the same time as a new Application Interface, and it
is assigned as the 'ssm node' property of that Interface; the Application
Intf itself now serves the same purpose for Rosetta::Dispatcher Engines as
Environment Intfs do for all normal Engine objects. All calls to
App->prepare(), except those with link_product_node SSM arguments, are
always routed to RD->prepare() in exactly the same way that Env->prepare()
is routed to RE[sub]->prepare(). All Interface object results from
App->prepare() that involve combining multiple normal Engine results will
now be direct children of the Application Intf, and have RD as their
Engine. Also, there is no longer any messing around with the user's
SQL::SyntaxModel; no lpn for RD will be added to it at any time. Also, the
POD warnings against invoking Rosetta::Dispatcher (or subclass thereof)
like an ordinary Engine in an lpn were removed, since any attempt to do so
will cause an exception in prepare(), which averts the problem. Also, the
simplified private _prepare_with_no_engine() was renamed to _prepare_lpn().
* Rosetta now officially supports the use of multiple Environment Intfs
that use the same Rosetta Engine class; however, each one must still be
built from a differnet link_product_node, and has a different root Engine
object. This is allowed since differing configuration options attached to
an lpn can make for diff 'global' Engine behaviour from the same class.
* Renamed the get_supported_features() method of Rosetta.pm to features()
and re-positioned it to be above prepare(). This function was overhauled
and can now be called off the same 4 Interface types that prepare() can:
Appl, Envi, Conn, Tran. This change allows better recognition for
individual Engines that can link to multiple database products that have
different capabilities, rather than requiring a separate Engine for each
product of varying abilities. Examples of benefitting Engines include those
that are generic proxy clients, or generic ODBC or ADO clients, or any-DBD
DBI wrappers, or clients that support multiple different-abled versions of
the same database product series (like MySQL 3.x + 4.x + 5.x). Also added
prepare() to Rosetta::Dispatcher, which handles the Appl case by combining
results of all available Engines.
* Updated the Interface._validate_ssm_node() private method, used by new()
and prepare(), so it now asserts that the given SSM Node has the Node
evolution status of "Well Known", and so it now invokes
test_deferrable_constraints() on that Node's Container; Rosetta is now only
accepting Node trees as input that pass all of SQL::SyntaxModel's own
tests. STILL TODO: Test deferrables after an Engine adds/changes Nodes.
* Reversed the addition in Framework.pod of Rosetta::Engine::GenericAC to
BRIEF MODULE LIST that was made in release 0.32; GenericAC no longer exists
as a separate module in Rosetta-Extensions. Other small Framework.pod
detail changes in regards to the potential Engines.
2004-08-06 Darren Duncan <perl@DarrenDuncan.net>
* Release 0.32.
* Updated external dependencies on Locale::KeyedText to v0.06 and on
SQL::SyntaxModel to v0.24.
* Updated all distribution code that makes use of UNIVERSAL::isa() to test
for valid objects so that it no longer incorrectly "passes" literal strings
whose string values match the class names of valid objects. For each test,
"UNIVERSAL::isa($obj,'<class-name>')" was replaced with "ref($obj) and
UNIVERSAL::isa($obj,'<class-name>')". Before the fixes, code that
UNIVERSAL::isa() was supposed to guard would eventually die with the
standard Perl error "Can't use string ('<class-name>') as a HASH ref",
rather than elegantly dealing with the bad input value.
* Updated lib/Rosetta.pm (now v0.16), lib/Rosetta/L/en.pm (now v0.07),
lib/Rosetta/Validator.pm (now v0.02), and lib/Rosetta/Validator/L/en.pm
(now v0.02). Many changes were made, in code and documentation.
* Added new documentation file lib/Rosetta/Features.pod which lists and
describes all of the RNI features which a Rosetta Engine could possibly
implement, and that Rosetta::Validator could possibly test an Engine for.
* Added new Rosetta::Interface method named payload(), which can only be
used with Literal Interfaces; you use it to retrieve the literal value(s)
that the Literal Interface represents. Rosetta::Engine also gained a
method of the same name, which Engines must implement.
* Added new Rosetta::Interface property accessor convenience method named
get_sibling_interfaces(), which works conceptually like
self.parent().children() but is more robust.
* Updated the STRUCTURE documentation so Literals can no longer be
grand-children of Applications. Fixed a code bug in "Interface.new()" so
that Literals would be accepted as grand-children of Environments or
Connections (in addition to Transactions) as the POD says it should.
* Added some error-handling code to Rosetta.pm, wrapping all calls to
Engine methods in eval blocks that weren't so wrapped before. Any caught
exceptions that are Message objects are simply re-thrown, and misc
exceptions (such as a Perl standard runtime error) are converted to Message
objects. Now a single ROS_I_METH_MISC_EXCEPTION message key in
Rosetta/L/en.pm is used for all methods, replacing some proprietary ones.
Added validation code to get_supported_features to check for valid arg
values, and valid return list values.
* Updated Interface.get_supported_features() so that it checks both input
arguments for being correct valid feature names, but it also checks the
return values of Engines to make sure the feature names they claim to
support match possible names that are actually in the Rosetta Interface
definition; these are the same names listed in Features.pod.
* Added a third inner class to Rosetta.pm called Rosetta::Dispatcher, which
collects together any code for mapping commands against Application
Interfaces to commands against Environment Interfaces. It is implemented
as a Rosetta::Engine sub-class, and Interface will invoke it automatically
at required times; you never reference it like a normal Engine. The new
class has 1 property, 'payload'.
* The old private Interface functions _prepare_with_no_engine() and
_get_or_make_environment_preparation() were combined into
_prepare_with_no_engine() and rewritten, with part of the code staying
there and the rest of it becoming the new Dispatcher class.
* Replaced or added a bunch of other message keys and user text in
Rosetta/L/en.pm that is relevant to various prepare() methods, and added
the first few Rosetta Generic Engine Error keys and user-text.
* Renamed a lot of the local variables in Rosetta.pm to be a lot more
consistent, descriptive, and scalable, meaning the code is now a lot easier
to read and understand. For example, any SSM Node objects now end in
'_node', any Interface objects end in '_intf', any Engine objects in
'_eng', any "preparation" interfaces or engines have '_prep' in the middle.
As an exception, for the few generic functions that can take many kinds of
intfs/engs rather than one specific kind, the variables are simply called
$interface or $preparation and $engine as before.
* Updated all user-text strings in Rosetta/L/en.pm so that the module-class
name appears at the start of each, to the left of the method names. This
should make it easier for users to know which code file among many
candidates is generating any error messages they see.
* A few other small bug fixes and changes were made in Rosetta.pm.
* Updated Validator.pm to add a list of constant values or properties, plus
its first two methods; the latter come with new POD documentation. Minor
SYNOPSIS update. Minor code update to Validator/L/en.pm.
* Small updates to Framework.pod. Added new modules Rosetta::Features and
Rosetta::Engine::GenericAC to BRIEF MODULE LIST. Another minor update.
* For the first time, with this release, most of the Rosetta.pm code has
now been exercised and tested, in combination with external code, and is
now found to be working to spec. Tests included successful runs of
DB_LIST, DB_OPEN, DB_CLOSE, and prepare( <data link product node> ).
2004-07-05 Darren Duncan <perl@DarrenDuncan.net>
* Release 0.31.
* This is mainly a documentation update and file reorganizing release; there
are no significant code changes.
* Updated external dependencies on Locale::KeyedText to v0.04 and on
SQL::SyntaxModel to v0.23.
* Updated Framework.pod in several spots. The "Schema" module group that
is referenced in several places is renamed to the "Model" module group. The
BRIEF MODULE LIST section now shows the upcoming "Rosetta-Validators"
distribution to be merged into the core "Rosetta" distribution, rather than
being separate; the Validator modules will also never make an appearance in
the "Rosetta-Extensions" as previously stated. Also, Rosetta::Validator
will be just a single module in the forseeable future, rather than a set.
Also, Rosetta::L::en will now take over the responsibility of storing the
ready-made set of generic database error strings that can be thrown by any
Rosetta Engine; the old Rosetta::Engine::L::en module in "Extensions" no
longer does this, but is now ::Generic specific (with appropriate rename).
A few more small changes, mainly in OLDER DOCUMENTATION: Engine Modules.
* Updated lib/Rosetta.pm (now v0.15) and lib/Rosetta/L/en.pm (now v0.06),
mainly with updated documentation. Most Rosetta.pm changes were in the
STRUCTURE POD, and internal property list declaration comments. The list
of Interface types now shows that any kind of preparation can return a
Literal-producing routine, and not just Transaction ones. Most en.pm
changes were in DESCRIPTION.
* Added new modules lib/Rosetta/Validator.pm and
lib/Rosetta/Validator/L/en.pm; both are at version 0.01. These are now
place-holder skeletons that have their main documentation but lack code.
2004-04-10 Darren Duncan <perl@DarrenDuncan.net>
* Release 0.30.
* Made a change that would mainly affect those people making Rosetta
Engines, but not other users; I am now dictating one aspect of how every
Engine should do its job, so they are less free-form than before (but
hopefully for the better). Like before, every successful call to prepare()
will produce a Preparation Interface; unlike before, every Preparation now
has an actual Perl "closure" (anonymous routine reference) behind it, which
is stored in an Interface property. All Engines must now structure their
prepare() methods so that they create an anonymous Perl subroutine which
does the actual work to be done; a call to execute() will simply invoke
this subroutine, and no actual Engine execute() method is called.
* Updated Rosetta.pm (now v0.14) and en.pm (now v0.05). Added a ROUTINE
property to the Rosetta::Interface class which is set in Preparation
Interfaces. Added argument to new() for setting it, and added method
get_routine() for fetching it. Removed execute() from the Rosetta::Engine
class, since prepare() now handles all the details that it used to do.
* Updated Rosetta.pm to add a new 'tombstone' Interface Type, which is what
commands that destroy Interfaces (such as 'close database') return to
indicate success. Interfaces of this type have no parents, like 'error'.
* Minor update to the names of prepare() and execute() arguments; COMMAND
is now called ROUTINE_DEFN and BIND_VARS is now called ROUTINE_ARGS.
* Minor capitalization changes in Framework.pod.
* Simplified the DEPENDENCIES documentation in the ReadMe file.
2004-03-25 Darren Duncan <perl@DarrenDuncan.net>
* Release 0.29.
* Updates in this release consist mainly of shunting some detail work out
of the 'Rosetta' distribution and towards the upcoming new
'Rosetta-Extensions' distribution. The rationale is that
Rosetta-Extensions can then be released more frequently without requiring
corresponding Rosetta releases to maintain compatibility. This is not to
say that some detail work won't be moved into the Rosetta core later, but
in the short term it seems best to keep it out.
* The new()/prepare() methods will no longer check that the Command Type of
a given "command" SSM Node is appropriate for the Interface type; it is
better, at least for now, that the Engine does this check. However, if the
invocant of prepare() is an 'application', then a more limited check is
still done, since the Rosetta core itself needs to implement them. Several
small documentation fixes were also made in Rosetta.pm.
* Corresponding updates in Rosetta.pm (now v0.13) and en.pm (now v.0.04)
related mainly to the prepare() method; several hard-coded "die" were
replaced with proper localized exceptions; several other exceptions were
renamed or moved.
* Updated Framework.pod to mention some additions to Rosetta-Extensions;
for example, that distro will contain the localized generic database error
messages for Engines instead of Rosetta::L::en. It will also contain the
initial set of Rosetta::Validator modules.
* All details in the TODO file of 'Rosetta' have been moved to the TODO in
'Rosetta-Extensions', which is where they are relevant. The TODO in
'Rosetta' now simply says to look over there; the 'Rosetta' core is
initially complete and most near-term work will now be in the other dist.
2004-03-22 Darren Duncan <perl@DarrenDuncan.net>
* Release 0.28.
* There are 4 distributions being released simultaneously that all have the
same release number of 0.28; this is one of them. They are:
SQL-SyntaxModel-0.28, SQL-SyntaxModel-ByTree-0.28,
SQL-SyntaxModel-SkipID-0.28, Rosetta-0.28. Each of the latter 3 is
dependant on the first 1. These 4 distributions cumulatively have almost
identical contents to the Rosetta-0.27 distribution, which is their sole
progenitor; that older distribution has hereby been split into 4 pieces
which will now be developed independently from each other. All 4 new
distributions inherit the external dependency on Locale-KeyedText-0.03.
* While those of Rosetta-0.27 were taken as a starting point, these CPAN
standard files have been changed to either a large or a small extent as
appropriate so that they represent the new 0.28 distribution: ChangeLog,
INSTALL, Makefile.PL, MANIFEST, ReadMe, TODO. (META.yml is generated.)
* This ChangeLog file has been truncated to exclude the details from
releases 0.01 thru 0.27, as they aren't very useful going forward and take
up a lot of space (about 90 kilobytes). If you want to read those details
then please look at an archived Rosetta-0.27 distribution, which is the
last one to have them.
* The distribution you are looking at now is not the first one to bear the
name Rosetta. For historical posterity, this is its file manifest:
- ChangeLog
- INSTALL
- lib/Rosetta.pm
- lib/Rosetta/Framework.pod
- lib/Rosetta/L/en.pm
- LICENSE
- Makefile.PL
- MANIFEST
- META.yml Module meta-data (added by MakeMaker)
- ReadMe
- t/Rosetta.t
- TODO
* All modules with version numbers have seen theirs incremented by 0.01
compared to Rosetta-0.27, and all modules or scripts that use them now
require the new numbers; said modules did not have any other significant
changes. In this distribution, Rosetta is now v0.12 and Rosetta::L::en is
now v0.03.
* A few other minor updates were made to several files.
2004-03-21 Darren Duncan <perl@DarrenDuncan.net>
* Rosetta-0.27, the last version of the distribution prior to its 4-way
split, was released on CPAN.
2003-01-27 Darren Duncan <perl@DarrenDuncan.net>
* Rosetta-0.02, the first version of the distribution under that name,
was released on CPAN.
2003-01-21 Darren Duncan <perl@DarrenDuncan.net>
The next version of the Module List will list the following module:
modid: Rosetta
DSLIP: cdpOp
description: Framework for RDBMS-generic apps and schemas
userid: DUNCAND (Darren Duncan)
chapterid: 7 (Database_Interfaces)
enteredby: ANDK (Andreas J. Knig)
enteredon: Tue Jan 21 08:20:47 2003 GMT
The resulting entry will be:
Rosetta cdpOp Framework for RDBMS-generic apps and schemas DUNCAND
2003-01-05 Darren Duncan <perl@DarrenDuncan.net>
* DBIx-Portable-0.01, the only version of the Rosetta distribution under
its previous name, was released on CPAN.
2002-11-12 Darren Duncan <perl@DarrenDuncan.net>
* Began development on the modules which became the pre-split Rosetta
distribution as their own entity that is separate from my application, for
open-source distribution on CPAN. The modules were to comprise an
RDBMS-generic DB framework for any application to use.
* Modules based on a template created by h2xs 1.18.
2002-07-28
* Posted the first significant update to the second prototype, which added
an index or cache for data that was expensive to calculate for each page
request, and involved rewriting about a fourth of the perl code.
2002-06-07
* Posted to my website the second public prototype demo of the new
self-proprietary database driven application, whose database schema, user
interface, feature set, and Perl application code was almost completely
rewritten. The new version explicitly had separate modules for database
communication and the web interface logic, with MySQL-specific code and
database generic or data dictionary code in separate files, and separate
files for parts of the web interface. The program used the same generic
CPAN modules as in the first prototype, DBI/MySQL and CGI::Portable.
2001-11-24
* Posted the last update to the first prototype.
2001-07-12
* Posted to my website the first public prototype demo of a new
self-proprietary database driven application, which is like a cross between
a multimedia metadata catalogue and a repository for historical or
genealogical data. This application contained the first prototypes of code
that ended up in these modules. All of this application's code, for
database communication and web interface logic, was situated in a single
module, with the rest of the program being more generic CPAN modules like
DBI (and DBD for MySQL) and CGI::Portable.
2000-05-17
* Requested MySQL database privileges on my web host so I have something to
start developing, testing and deploying database driven applications on.