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.