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. Kšnig)
	  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.
