2005-03-18   Darren Duncan <perl@DarrenDuncan.net>

	* Release 0.41.

	* New code file versions are: Rosetta.pm and Validator.pm v0.41,
	Rosetta/L/en.pm v0.15, and Validator/L/en.pm v0.09.

	* Updated external dependencies Locale::KeyedText to v1.02 and on
	SQL::Routine to v0.56.

	* Corrected a few spelling mistakes in the documentation.

	* In order to help ease the transition to Perl 6, updated Rosetta/L/en.pm
	and Validator/L/en.pm to make all user text message strings bound in
	non-interpolating single quotes rather than interpolating double-quotes. 
	The reason is because these text strings frequently use literal braces ({})
	and Perl 6 would have incorrectly interpreted those as containing embedded
	Perl code to execute and interpolate the result value of.

	* Following a style suggestion given to me by Larry Wall on p6l, updated
	every occurance of a "return" statement in the distribution to remove the
	parenthesis around its value list, since it is a an operator rather than a
	function; this also makes my code more consistent since I never used parens
	for the likes of "sort" or "keys" or "next" or "last".  Also updated every
	"return" to not explicitly return undefs (that's what "return" does by
	default), and also to not return a generic truth value ("1") when any caller
	would ignore it.

	* Deleted the SYNOPSIS content in Validator.pm, leaving a promise of
	something better to come.

	* Updated any DEPENDENCIES documentation to use sub-headings "[|Non-] Core
	Modules" rather than "[|Non]standard Modules".

	* Added a section in the TODO file about an imminent branch from this
	distribution of a version written in Perl 6, initially useable with Pugs.

	* Added a similar comment in the portion of Framework.pod that talks about
	future directions.  Made a few other minor Framework.pod updates.

2004-12-18   Darren Duncan <perl@DarrenDuncan.net>

	* Release 0.40.

	* This distribution now requires Perl 5.008001 or higher; it was 5.006.

	* All files in this distribution are now officially UTF-8 encoded, though
	they continue to have no BOM, and they still have Unix line-breaks.  Any
	files that contain code now have the "use utf8" pragma.  Any files that
	contain POD now have "=encoding utf8" as the first POD command paragraph.

	* All distro files that contain code, whether *.[pm|pl|PL|t], now begin with
	"#!perl" on their first line, and the second line contains "use 5.008001;
	use utf8; use strict; use warnings;"; all other code and POD is below those.
	Within the *.pm files, the "package ... $VERSION ..." now appears above all
	of the POD; also, the NAME and DEPENDENCIES POD now have nothing between
	them.  Within the *.t files, there is no longer any BEGIN/END $loaded test,
	but the test now simply prints "ok 1 ..." if the modules loaded.

	* Updated any SEE ALSO module references to be L<>.

	* New code file versions are: Rosetta.pm and Validator.pm v0.40,
	Rosetta/L/en.pm v0.14, and Validator/L/en.pm v0.08.

	* Updated external dependencies on Locale::KeyedText to v1.01 and on
	SQL::Routine to v0.52.

	* This is primarily a maintenance release whose purpose is to maintain 
	compatability with recent SQL::Routine changes.  There are no significant 
	Rosetta feature changes.

	* In the Rosetta.pm Interface class, deleted the 2 private methods
	_build[|_child]_node() and simplified the 2 private methods
	_build[|_child]_node_auto_name().  Then simplified these public methods: 
	build_application(), build_child_environment(), build_child_connection(), 
	sroutine_catalog_list(), sroutine_catalog_open(), sroutine_catalog_close().

2004-11-23   Darren Duncan <perl@DarrenDuncan.net>

	* Release 0.39.

	* New code file versions are: Rosetta.pm and Validator.pm v0.39,
	Rosetta/L/en.pm v0.13, and Validator/L/en.pm v0.07.  There were zero changes
	in Features.pod and Framework.pod.

	* Updated external dependencies on SQL::Routine to v0.50.

	* This release primarily consists of moving a large block of functionality
	from Validator.pm to Rosetta.pm, further improving it in the process.  The
	changes are described below in terms of additions and removals.

	* In Rosetta.pm, rewrote the DESCRIPTION documentation; now it better
	describes the purpose, features, strengths, and distinctiveness of this
	module, than the old documentation did.  Also deleted the out-dated
	SYNOPSIS, which will be rewritten later.

	* Removed the 3 SRTNTP_[APPINST|LINKPRD|ROUTINE] named constants in
	Rosetta.pm; the code that used them now just uses string literals instead.

	* Added new Interface method get_srt_container(), which complements
	get_srt_node(); you can get an Interface tree's container with just one
	method call.  Added new Interface method do(), which wraps an associated
	prepare() and execute(); this is like the relationship of DBI's 3
	same-named	methods.  Updated the Dispatcher class methods to make use of
	these 2 new methods.  Also updated Dispatcher._prepare__call_engine() to 
	account for a SRT Node attribute nename to 'blueprint' from 'unrealized'.

	* Added a set of new Interface functions and methods to assist in rapid
	user code development; they are wrappers around other Rosetta and
	SQL::Routine methods.  These 9 public ones are documented under INTERFACE
	FUNCTIONS AND METHODS FOR RAPID DEVELOPMENT: build_application(),
	build_application_with_node_trees(), build_environment(),
	build_child_environment(), build_connection(), build_child_connection(),
	validate_connection_setup_options(), destroy_interface_tree(),
	destroy_interface_tree_and_srt_container().  These 3 public ones are
	documented under CONNECTION INTERFACE METHODS FOR RAPID DEVELOPMENT:
	sroutine_catalog_list(), sroutine_catalog_open(), sroutine_catalog_close().
	These 5 private ones are used by the previous 2 groups: _build_node(),
	_build_node_auto_name(), _build_child_node(),
	_build_child_node_auto_name(), _destroy_interface_tree().  Added global
	dictionary structure %BC_SETUP_NODE_TYPES which is used by
	validate_connection_setup_options().  Added 8 new messages to
	Rosetta/L/en.pm, 1 ROS_I_BUILD_CH_ENV_NO_ARG for build_child_environment()
	and 7 ROS_I_V_CONN_SETUP_OPTS_* for validate_connection_setup_options().

	* Most of Validator.pm was rewritten in some manner or other, though its
	net feature set is identical to the previous release; that is, what it
	tests and how it tests that is the same.  While Rosetta::Validator is still
	technically an object, you no longer invoke it as such; you no longer
	invoke a constructor and then object methods.  Rather, you now simply
	invoke the main() class function, which takes all config options as its
	arguments, and returns the test results itself upon completion.  Any
	objects are created and destroyed during the execution of main().  Added
	these 5 functions/methods: main(), setup_app(), setup_env(), setup_conn(),
	main_dispatch().  Removed these 20 functions/methods:
	_throw_error_message(), _setup_test(), _takedown_test(),
	_takedown_test_destroy_intf_tree(), new(), [get|clear|set]_trace_fh(),
	[get|clear|set]_engine_name(), [get|clear|set]__engine_config_option[s](),
	[get|clear]_test_results(), perform_tests().  Renamed the 4
	_[new|pass|fail|misc]_result() methods to [new|pass|fail|misc]_result().
	Renamed the 5 perform_tests_*() methods to test_*(); also, of the 3 that
	were implemented, they are a lot shorter now, since most of the code was
	moved into Rosetta.pm.  Added these 3 main documentation sections: SYNTAX,
	PUBLIC FUNCTIONS, INTERPRETING THE TEST RESULTS; the only public functions
	listed are total_possible_tests(), main().  Removed these 5 main sections:
	CONSTRUCTOR FUNCTIONS AND METHODS, STATIC CONFIGURATION PROPERTY ACCESSOR
	METHODS, DYNAMIC STATE MAINTENANCE PROPERTY ACCESSOR METHODS, TEST
	PERFORMING METHODS, INFORMATION FUNCTIONS AND METHODS.  Removed all 8
	messages from Validator/L/en.pm that were associated with exceptions that
	Validator.pm would throw; Validator.pm no longer throws any exceptions, and
	the removed messages were replaced by new ones in Rosetta/L/en.pm.

	* Rewrote the Validator.pm SYNOPSIS to account for the updates and be more 
	robust, plus provide better input data examples.

	* Following all of the above changes, Validator.pm is about half the file
	size that it used to be, and Rosetta.pm is about a quarter larger.

2004-11-06   Darren Duncan <perl@DarrenDuncan.net>

	* Release 0.38.

	* New code file versions are: Rosetta.pm and Validator.pm v0.38, and
	Validator/L/en.pm v0.06.

	* Updated external dependencies on SQL::Routine to v0.48.

	* There were no changes to Rosetta.pm except for the version and dependency 
	number increments.  Zero changes to Rosetta/L/en.pm and Features.pod.

	* This release is primarily a major upgrade to Validator.pm and its en.pm
	file.  Previously, they had almost no code at all, and now they have a host
	of utility functions plus testing functions for the CATALOG_LIST and
	CONN_BASIC Rosetta features.  Externally, the Rosetta-Extensions
	distribution is now using Rosetta::Validator as the primary component of
	its t/*.t test suite, so it is being put to practical use.  Details follow.

	* In Validator.pm, added 3 new class properties, "trace fh", "engine eco",
	"eng env feat"; these complement the existing 2 properties, "engine name"
	and "test results".  The single accessor method for "engine name" was split
	into 3 methods; added 3 for "trace fh", 6 for "engine eco", and 2 for "test
	results"; "eng env feat" is private and has no accessors.

	* Added 8 new private utility functions: _throw_error_message(),
	_new_result(), _pass_result(), _fail_result(), _misc_result(),
	_setup_test(), _takedown_test(), _takedown_test_destroy_intf_tree().

	* Added the first set of 6 methods that do the real work of Validator:
	perform_tests(), perform_tests_load(), perform_tests_catalog_list(),
	perform_tests_conn_basic(), perform_tests_catalog_info(),
	perform_tests_tran_basic(); the last 2 don't do anything yet, but the first
	4 are more or less complete.  You should only invoke perform_tests()
	directly, and it invokes the others; the others are private.

	* Added new Validator information function total_possible_tests(); it
	currently returns a value of 5, which is the number of elements that
	get_test_results() will return after perform_tests() is called.

	* Rewrote the SYNOPSIS in Validator.pm to provide a fully functional 
	example, similar to the Rosetta-Extensions t/*.t file.

	* Added the first 15 user-text messages to Validator/L/en.pm; of these, 8
	are error messages thrown when Validator.pm gets bad method inputs, 5 are
	the description text for the first/current 5 test results, and 2 are
	Validator-specific test failure messages.

	* Updated Framework.pod to remove all mention of the historical posterity
	distribution SQL-Routine-Castaways and its modules SQL::Routine::ByTree and
	SQL::Routine::SkipID.  During this last week, all of the useful code in
	that distribution was merged into the core SQL::Routine module, and the
	test suites for ByTree and SkipID were also adapted into SQL-Routine; 
	Castaways and ByTree and SkipID no longer exist as distinct entities.

	* Other minor updates in Framework.pod.

2004-10-26   Darren Duncan <perl@DarrenDuncan.net>

	* Release 0.37.

	* From now on, Rosetta::Validator will have the same version number as
	Rosetta itself (and the distribution), because they are by design always 
	supposed to be updated in tandem.

	* New code file versions are: Rosetta.pm and Validator.pm v0.37,
	Rosetta/L/en.pm v0.12.

	* This is a major release, with multiple significant design, code, and
	documentation updates, mostly in Rosetta.pm, and also in Rosetta/L/en.pm.

	* Updated external dependencies on SQL::Routine to v0.45.

	* Corresponding to a SQL::Routine change, all references to the 'command'
	SRT Node types were removed; that temporary stop-gap feature has now been
	fully replaced with user-defined routines containing calls to corresponding
	standard built-in routines.  All SRT built-in standard routines now take
	named arguments rather than positional ones, just like SRT user-defined
	routines; they can now all be used in the same ways.

	* Now, 'routine' Nodes are the only acceptable input to prepare(), except
	for the few circumstances where they take 'application_instance' or
	'data_link_product' Nodes.  Updated Interface._validate_srt_node() and
	added 2 corresponding new user text strings to Rosetta/L/en.pm.

	* Changed the nature of how 'Connection' Interfaces are created, used, and
	changed.  Now, a 'Connection' Interface is created by an Engine when an
	executed SRT routine declares a variable of type 'CONN'; most details of
	the Connection are provided at that time.  A Connection now has two
	distinct states, being 'open' or 'closed', which it must be explicitly set
	to using the CATALOG_OPEN() and CATALOG_CLOSE() SRT standard routines; a
	Connection is no longer implicitly open simply by its existence; a brand
	new Connection Interface starts out closed.  As a result of this change,
	you can now declare a Connection in a different user-defined routine than
	you open it in; also, you can now close and reopen a database connection
	multiple times with the same Connection, rather than having to make a new
	Connection for each time (it is also now easier to represent cached
	database connections).  This also corresponds to a SQL::Routine change.

	* Changed the nature of 'Cursor' Interfaces to be the same as 'Connection'
	Interfaces now are, namely declaration with a SRT routine variable, having
	distinct 'open' and 'closed' states set with CURSOR_OPEN() and
	CURSOR_CLOSE(), and so on.  This new behaviour also matches the way that
	cursors are handled in the SQL:2003 procedural language.  The 'Cursor'
	Interface type can now have child 'Preparation' and grand-child 'Literal'
	Interfaces, just like [App,Env,Conn] do.

	* Deleted the 'Transaction' Interface type, which was mostly redundant with
	'Connection'; anything that referenced or linked to it now does with
	'Connection' instead.  This may be brought back later, but for now it adds
	needless complexity.

	* Renamed the 'Tombstone' Interface type to 'Success', and expanded its
	usage.  An Interface of this type is now returned implicitly from all
	'PROCEDURE' user-defined routines that complete execution successfully.  It
	is not used with 'FUNCTION' routines since those are supposed to explicitly
	return some other kind of Interface type when executing, either a "context"
	Interface (Env,Conn,Curs) or a 'Literal' Interface.

	* The Interface name constant declarations inside Rosetta.pm are now
	declared using 'our' rather than 'my'; external code can now reference them
	directly for reading, rather than having to re-declare their own copies.

	* Added new Interface property 'trace_fh' and 3 associated accessor methods
	[get|clear|set]_trace_fh().  Unlike other Interface properties, which can
	only be set on object creation, this new property is set after object
	creation, and can be changed at will.  It holds a Perl file-handle
	reference that is open for writing.  When this property is set, a Rosetta
	Engine can write useful debugging information to it as the code runs, to
	help you understand what is happening behind the scenes and when.  For
	example, when a user-defined routine is compiled to Perl code and/or SQL
	from a SQL::Routine, then that Perl/SQL code can be output.  You turn
	tracing on and off by setting or clearing the new property.

	* Added new 'Environment' Interface method routine_source_code() to both
	the Interface and Engine classes; all Rosetta Engine sub-classes must
	implement this method.  This method is intended to help with debugging, and
	will return the generated Perl/SQL source code for the 'routine' SRT Node
	given as its argument.  The method does not generate that code, but rather
	returns code that was previously generated when the same 'routine' SRT Node
	was given to prepare(), or another 'routine' that invokes it was given to
	prepare(); this new method returns undef if that hadn't happened.

	* Deleted the following 4 'Cursor' Interface methods from both the
	Interface and Engine classes: finalize(), has_more_rows(), fetch_row(),
	fetch_all_rows().  These have been fully replaced by different SRT built-in
	standard routines, such as CURSOR_CLOSE() and CURSOR_FETCH(), that you call
	in a SRT user-defined routine that uses a 'Cursor' as its action context.

	* Renamed a couple Rosetta features to "CATALOG_[LIST|INFO]" from
	"DB_[LIST|INFO]"; this affects Rosetta.pm and Features.pod; in the latter
	case, it is the only change to the file.  CATALOG_LIST now also behaves
	differently, in that it returns a list of new 'catalog_link' Nodes rather
	than 'catalog_link_instance' Nodes that it did before; this is now the same 
	kind of Node that is used when creating new 'Connection' Interfaces.

	* Updated the inheritable _throw_error_message() method to set the Message
	argument 'CLASS' with the name of the current (Engine) class, if 'CLASS'
	isn't already set; this saves users of the function from having to pass
	that redundant argument.

	* Rewrote most of the Rosetta::Dispatcher class.  The methods
	prepare_cmd_db_list() and prepare_cmd_db_open() were recombined into
	prepare() and a very different set of _prepare__*() methods.  The new
	version is a lot more versatile and will do the right thing with a much
	wider range of input routine types; before it worked with exactly 2 kinds
	only.  Added new error message ROS_D_PREPARE_NO_ENGINE_DETERMINED, used by
	Dispatcher, to Rosetta/L/en.pm; this replaces 3 older 'ROS_G_PREPARE_*'
	messages, which were removed.

	* Added 6 new 'ROS_G_*' messages to Rosetta/L/en.pm and removed the last
	pre-existing one, ROS_G_CMD_DB_CLOSE_CONN_IN_USE.

	* Replaced all documentation occurances of "SQL-2003" with "SQL:2003".

	* Note that the SYNOPSIS in Rosetta.pm is now out of date, and wrong.  It
	will be fixed later.

	* Updated all code that referenced module version numbers so that those
	numbers are now quoted in strings rather than being bare numbers.  In the
	*.pm files, this affected only the "use" strings, since each $VERSION was
	already declared as a string.  In the *.t files, the "use" strings.  In the
	Makefile.PL, each PREREQ_PM item was updated.

	* Other minor updates in Framework.pod and Rosetta.pm.

2004-10-04   Darren Duncan <perl@DarrenDuncan.net>

	* Release 0.36.

	* New code file versions are: Rosetta.pm v0.36, Rosetta/L/en.pm v0.11, 
	Validator.pm v0.06, and Validator/L/en.pm v0.05.

	* Updated external dependencies on Locale::KeyedText to v1.00 and on
	SQL::Routine to v0.43.  SQL::Routine was renamed from SQL::SyntaxModel.

	* Renamed all references on SQL::SyntaxModel in code and documentation to
	SQL::Routine.  All name-related strings, both in code and documentation,
	were updated as follows: "SyntaxModel" -> "Routine", "SSM" -> "SRT", "ssm"
	-> "srt".  Most renaming was done in Rosetta.pm and Framework.pod.

	* Updated the _validate_srt_node() private method of Rosetta.pm to remove
	the assertion using are_reciprocal_links(), that method no longer exists in
	SQL::Routine (it isn't needed); removed 2 corresponding *NOT_RECIP_LINKS
	user text messages in Rosetta/L/en.pm.

	* Updated the SYNOPSIS and BUGS documentation in Rosetta.pm.  Fixed a bug
	in the new_application() method documentation regarding the invocant.

	* Updated Framework.pod: Rewrote a chunk of the OLDER DOCUMENTATION in
	regards to Engine modules.  Updated the BRIEF MODULE LIST to account for
	the SQL-Routine and SQL-Routine-Castaways distros, and the Engines.

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. 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.
