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

	* SQL-Routine Release 0.50.

	* New code file versions are: Routine.pm v0.50 and en.pm v0.20.

	* This release takes the recently imported "SkipID" code related to the
	"default attribute" feature and makes the support more elegant.  As a
	side-effect, this functionality is now divorced from the "abstract
	interface", and will be used regardless of whether the "use abstracts" flag
	is set.

	* Added new node_types_with_surrogate_id_attributes() information function.

	* Added 4 new Routine.pm methods: expected_surrogate_id_attribute_name(),
	[get|clear|set]_surrogate_id_attribute(); also added 2 related en.pm
	messages: SRT_N_EXP_SI_AT_NO_SI, SRT_N_SET_SI_AT_NO_ARGS.  They allow you
	to work with a Node's surrogate id attribute, if it has one, as easily as
	you can work with the normal Node id.  Reverted set_attributes() to its
	v0.47 state, such that it does not accept anything except a hash ref as
	input; removed the en.pm message 'SRT_ABSINTF_N_SET_ATS_BAD_ARGS'.  Updated
	the private method _build_node_is_child_or_not() and the public method
	build_lonely_node() so that, if either detects a non-hash but defined ATTRS
	argument, it builds a new one having a single element, where the value is
	ATTRS and the key is either 'id' or the new Node's surrogate id attribute
	name, depending on whether the value looks like a valid Node id.  Added new
	private method _build_node_normalize_attrs() which both previous methods
	now call.  Given these combined changes, the build*() methods still behave
	the same as v0.49 with respect to non-hash ATTRS arguments, except that the
	fallback action when not given a Hash ref is now always performed; there is
	no switch to turn it on or off.

	* Changed build_container() so that it is like build_child_node_trees()
	aside from also building the Container, instead of being like
	build_child_node_tree(); therefore, the main arguments have changed.  Also,
	there are 3 new optional arguments to build_container() which will set the
	corresponding 3 flag properties of the new Container.  As a result of the
	change, build_container() will take all of the varieties of Node descriptor
	input that you can use in other situations.

	* Rewrote part of the Routine.pm SYNOPSIS Trivial Example to better
	demonstrate the module's multi-layered API, using both build*() methods and
	set_*() methods; the serialization is identical to the old one.  Also
	updated the t_SRT_Circular.pm test module to use the build*() methods.

	* Updated set_literal_attribute() to add a new input validation test that
	prevents acceptance of non-scalar Perl reference values in the ATTR_VALUE
	argument when the literal attribute type was a 'cstr' or 'misc'; also added
	a corresponding user message to en.pm, SRT_N_SET_LIT_AT_INVAL_V_IS_REF.

	* Added a couple DESCRIPTION paragraphs, one on how easy this distro is to
	install, and one that mentions the module's multi-layered API.

	* Added a CAVEATS paragraph to Routine.pm that warns against setting Node
	surrogate id values that look like normal Node id values, since some
	methods won't do what you expect when given such values.

	* Corrected a bug present in most Routine.pm information functions such
	that each returned nothing instead of a list; also a few other small fixes
	to these functions.

	* Multiple corresponding data-dictionary updates in Language.pod and
	Routine.pm; these are the only changes in Language.pod.  Renamed the
	'unrealized' attribute of 'catalog_link_instance' Nodes to 'blueprint'.  In
	that Node type and 'catalog_instance', moved the 'blueprint' attribute
	above 'product'.  In 'catalog_instance', deleted these 3 attributes since
	link Nodes handle them instead: local_dsn, login_name, login_pass.  Removed
	a comment saying some of these attributes may be replaced by *_opt Nodes;
	they won't be, and in fact only those attributes should be used.  Removed
	the 'standard_routine' enumerated value 'SOME', which is a synonym for
	'ANY'.  Corresponding minor updates to t_SRT_Verbose.pm.

	* Small hyperlink documentation fixes in Language.pod.

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

	* SQL-Routine Release 0.49.

	* New code file versions are: Routine.pm v0.49 and en.pm v0.19.

	* This release constitutes a partial digestion of the recently imported
	"SkipID" code, such that the functionality in question was rewritten in a
	more elegant fashion.

	* Corresponding Language.pod and Routine.pm update that saw the set of
	"always mandatory" (MA) Node attributes divided into two groups, with one
	group being promoted to a new "surrogate id" (SI) type.  Not all Nodes
	have a SI attribute, but at least 2/3 of them do; each of those has exactly
	one of them.  SI attributes are implicitly both always-mandatory and always
	distinct under a common "primary-parent" (PP) Node.  All attributes that
	were promoted to SI were also renamed to have a "si_" name prefix; most of
	them were "name"/"si_name".  About half of the "Distinct Child Groups List"
	constraints were removed, as the new SI distinctness constraints took over
	their roles.  In Language.pod, all changes were in the NODE TYPES main
	section, and per-Node sub-sections.  In Routine.pm, most changes were in
	the %NODE_TYPES (and new %TYPE_CHILD_SI_ATNMS) data-dictionary and the
	_assert*constraints() Node methods.  In en.pm, added 3 new keys used by the
	SI constraints: SRT_N_ASDC_SI_VAL_NO_SET, SRT_N_ASDC_SI_NON_DISTINCT[_PSN].

	* Updated all 4 t_SRT_*.pm test libraries to account for the attribute name
	prefix additions; they did not require any other changes.  Made a similar 
	update to the Routine.pm SYNOPSIS and other code examples.

	* In Routine.pm, stripped down the %NODE_TYPES_EXTRA_DETAILS data
	dictionary to just contain the 'search_paths'; the removed
	'link_search_attr' and 'def_attr' were fully replaced by the new
	$TPI_SI_ATNM in %NODE_TYPES.  Minor updates were made to these methods that
	used the stripped values so they use the SI values:
	_set_node_ref_attribute__*(), set_attributes().  As a result of the second
	change, the "default" attribute of a Node is its surrogate id.

	* Deleted these 3 information functions from Routine.pm:
	mandatory_node_type_[literal|enumerated|node_ref]_attribute_names()

	* In en.pm and Routine.pm, consolidated the SRT_N_ASDC_MA_VAL_NO_SET user
	text message from these 3: SRT_N_ASDC_MA_[LIT|ENUM|NREF]_VAL_NO_SET.

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

	* SQL-Routine Release 0.48.

	* New code file versions are: Routine.pm v0.48 and en.pm v0.18.

	* This release mainly serves to merge two previously distinct modules into
	one; SQL::Routine::SkipID has been merged into SQL::Routine, and no longer
	exists as its own entity.  Likewise, the whole SQL-Routine-Castaways
	distribution no longer exists as a distinct entity.  The code that was
	SkipID.pm should be rewritten in the process, but isn't yet; however, other
	existing Routine.pm code was rewritten to accomodate the new arrivals
	and/or fix bugs introduced in release 0.47.  Similarly,
	SQL::Routine::SkipID::L::en was merged into SQL::Routine::L::en. The
	details of this merger are given below, but simply in terms of new
	functionality being added to Routine.pm.

	* Rewrote the following 3 methods in both the Container and the Node
	classes: build_node(), build_child_node(), build_child_node_tree().  Now
	these methods all require the Node they are invoked on to be in a Container
	(or be invoked on a Container) or they throw an exception; added 2 related
	user-text messages to en.pm, "SRT_N_BUILD[_CH]_ND_NOT_IN_CONT".  Now these
	methods share a lot more code with each other, either invoking each other
	to do part of their work, or a new private Container method
	_build_node_is_child_or_not(); combined 2 "*_NO_PSND" items in en.pm into
	1.  None of those methods invoke build_lonely_node(), which is now the only
	method invokable without a Container.  These methods no longer throw an
	exception due bad a ATTRS argument; they set set_attributes() do that for
	them; deleted 4 "*_BAD_ATTRS" user-text messages from en.pm.  All 3 methods
	now explicitly do the Node creation steps in this order where possible: set
	the Node id, put Node in Container, set the primary-parent attribute and
	info; lastly, all remaining Node attributes are set, and child creation
	follows all of that as before.  The 3 methods now all have identical
	behaviour as to whether they will generate a missing Node Id or not; there
	is no more some doing it one way and some another.  These changes combine
	to fix a bug where using the build_*() methods in some natural ways failed,
	such as with errors like "can't link node in container to one that's not".

	* Added new Container class boolean property (defaults false) and accessor
	method auto_assert_deferrable_constraints() which only affects the
	build_*() methods; if it is set true, then build_*() will test all of a
	newly created Node's constraints before returning it, or making any child
	Nodes.  The pre-merge Routine.pm behaviour corresponded to a false setting,
	and the pre-merge ByTree.pm and SkipID.pm corresponded to a true setting.

	* Added new Container class boolean property (defaults false) and accessor
	method auto_set_node_ids(); if it is set true, then the
	Node.put_in_container() method will automatically generate and set the
	Node's Id if it isn't set, rather than throwing an exception, prior to
	putting the Node in the Container.  The put_in_container() method is the
	only thing that reads this property, but it is used everywhere, including
	by your own external calls and by the build_*() methods.  The pre-merge
	Routine.pm and ByTree.pm behaviour corresponded to a false setting, and the
	pre-merge SkipID.pm corresponded to a true setting.

	* Added new Container class boolean property (defaults false) and accessor
	method use_abstract_interface(), which currently affects the Node methods
	set_node_ref_attribute() and set_attributes(), that are used frequently.
	Most of the new code, data, and documentation inported from SkipID.pm
	corresponds to this feature, where the above 2 methods (and many other
	methods which invoke them) will accept a wider range of input data without
	complaint than would otherwise happen; using this feature, you can specify
	a link from one Node to another using a non-Id attribute, such as the
	'name', which is more like how things work in normal SQL strings; combined
	with the previous auto-set feature, you can use SQL::Routine without ever
	having to see a Node Id.  The pre-merge Routine.pm and ByTree.pm behaviour
	corresponded to a false setting, and the pre-merge SkipID.pm corresponded
	to a true setting.

	* Related to the "abstract interface" feature, the following was added to
	Routine.pm, mostly verbatim (but trimmed down) from SkipID.pm: 1. The
	%NODE_TYPES_EXTRA_DETAILS data-dictionary structure where each list element
	has up to 3 parts, 'search_paths', 'link_search_attr', 'def_attr'. 2. Added
	code to set_node_ref_attribute(). 3. Added these 3 private methods, all of
	whose names start with "_set_node_ref_attribute__"; do_when_no_id_match(),
	find_node_by_link_search_attr(), search_for_node(). 4. Added code to
	set_attributes(). 5. Added main documentation section "ABOUT THE OPTIONAL
	ABSTRACT INTERFACE", which was derived from SkipID's "DESCRIPTION".  Also 
	related to "abstract interface", these two messages were added to en.pm: 
	SRT_ABSINTF_N_SET_NREF_AT_NO_ID_MATCH, SRT_ABSINTF_N_SET_ATS_BAD_ARGS.

	* There were zero changes to Language.pod and API_C.pod in this release.

	* Added a fourth tester module t_SRT_Abstract.pm, which SQL_Routine.t
	invokes; this tester module is the same t_SQL_Routine_SkipID.pm that came
	with SQL::Routine::SkipID, renamed and slightly modified in code.  However,
	the XML data provided for output comparison reflects a major bug fix, since
	the old version had several views erroneously children of other views,
	rather than the schema.  The new test count goes from 1..12, up from 1..9.

	* Minor update to t_SRT_Terse.pm so that it sets
	auto_assert_deferrable_constraints() to true, so the test emulates what the
	old ByTree.pm actually used to do.

	* The code added to Routine.pm wasn't identical to that removed from
	SkipID.pm; these are the main changes:  1. Removed the feature that
	automatically assigned a parent Node to a new Node that was the last
	previously created Node of an appropriate type; this feature had little
	practical value, and was very prone to errors based on context, as
	mentioned above.  2. Removed the feature that set a few default values for
	certain Node attributes, such as the base_type of a data type, or the
	view_type of a view; its value was dubious, and it was rarely used.

	* For historical posterity, I have extended this ChangeLog file to include
	all of the ChangeLog details that were posted on or after 2004-03-22 for
	all distributions that had code which became SQL::Routine v0.48; in other
	words, these are all the details since this code base was part of the
	Rosetta-0.27 distribution (note that, as of today, the other distros split
	from Rosetta-0.27 never had their ChangeLogs truncated after 2004-03-22
	either).  The distros that these details come from are:

		SQL-SyntaxModel-0.28 thru SQL-SyntaxModel-0.42
		SQL-SyntaxModel-ByTree-0.28 thru SQL-SyntaxModel-ByTree-0.30
		SQL-SyntaxModel-SkipID-0.28 thru SQL-SyntaxModel-SkipID-0.30
		SQL-Routine-0.43 thru SQL-Routine-0.48 (the latter is today's)
		SQL-Routine-Castaways-0.31 thru SQL-Routine-Castaways-0.33

	* In one of the next few releases, this ChangeLog will be re-truncated to
	only provide details following this 0.48 release, wherein there is only a 
	single code module to be concerned with, as was the case about a year ago.

	* For historical posterity, the total (uncompressed) file size of the
	SQL-Routine-0.48 distro is about 645K.  Of that, the 4 core .pm/.pod files
	are about 400K, the 5 test suite files are about 140K, and this ChangeLog
	is about 85K.

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

	* SQL-Routine-Castaways Release 0.33.

	* New code file versions are: SkipID.pm v0.33, SkipID/L/en.pm v0.08.

	* Updated external dependencies on SQL::Routine to v0.47 (newest release).

	* SQL::Routine::SkipID has now been reverted conceptually to the state it
	was in during its 2003-12-18 release in the Rosetta-0.19 distribution.  At
	that time, it did not add any new methods to the API of its super-class,
	but simply overrode a few parent methods to make those less stringent in
	what input data they accepted.  This state ceased to be with Rosetta-0.20,
	because some of the public methods that SkipID.pm needed were also split
	from its super-class.  However, those public methods rejoined the
	super-class in SQL-Routine-0.47, so SkipID can now regain its old status
	and no longer declare those extra public methods itself.

	* The DESCRIPTION of SkipID.pm was reverted to its 2003-12-18 state, except
	for a few tiny fixes.  Also, the entire 2 SkipID.pm POD sections entitled
	[CONTAINER|NODE] OBJECT METHODS were removed.  Tiny SYNOPSIS fix.

	* Renamed the 2 SkipID.pm methods Container.create_node_tree() and
	Node.create_child_node_tree() both to
	[Container|Node].build_child_node_tree(), and updated their code to more
	closely resemble the SQL::Routine methods they are overriding.  Also
	deleted the 2 user messages "SRTSID_[C|N]_CR_NODE_TREE_NO_ARGS" from en.pm,
	as these updated methods no longer use them; that is the only en.pm change.

	* Deleted the 2 SkipID.pm methods create_[child_]node_trees() as they are
	now completely redundant with the parent's build_child_node_trees() methods.

	* Renamed any calls on the parent's *parent_node*() methods to *pp_node*().

	* Made several %NODE_TYPES_EXTRA_DETAILS data dictionary changes in
	SkipID.pm.  All Node types and attribute names having 'col' were renamed to
	'field'; also, any 'ind' were renamed to 'index'.  The 'domain' Node type
	was renamed to 'scalar_data_type', and these types were added:
	'row_data_type', 'row_data_type_field'.  The 'search_paths' were added or
	updated for these Node types: table_field, table_index_field,
	view_src_field, view_field, view_join_field, view_expr.  The view.view_type
	default value changed from 'MULTIPLE' to 'JOINED'.

	* Multiple significant updates to t_SQL_Routine_SkipID.pm, to bring it up
	to date with all the SQL::Routine v0.46 and v0.47 changes, plus the
	effective renaming of the Node-tree-building methods.

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

	* SQL-Routine-Castaways Release 0.32.

	* Starting with this release, SQL::Routine::ByTree no longer exists as its
	own entity; it had been merged into the separately distributed SQL::Routine
	with the latter module's v0.47 release.  The SQL-Routine-Castaways
	distribution now only contains the SQL::Routine::SkipID module, which was
	split off from Routine.pm a lot earlier than ByTree.pm was, and hence is
	too much of a challenge to re-integrate at the present time.

	* These 4 files were removed from the Castaways distribution, and all
	references to them in other files (save the ChangeLog) were also removed:

		lib/SQL/Routine/ByTree.pm
		lib/SQL/Routine/ByTree/L/en.pm
		t/lib/t_SQL_Routine_ByTree.pm
		t/SQL_Routine_ByTree.t

	* New code file versions are: SkipID.pm v0.32, SkipID/L/en.pm v0.07.

	* Updated external dependencies on SQL::Routine to v0.45.  While that isn't
	the newest SQL::Routine release, it is the newest version for which
	maintaining compatability in SQL::Routine::SkipID is easy.  The next
	SQL-Routine-Castaways release should bring SkipID up to date, which will
	require more massive changes; those were skipped today since the main
	purpose of the v0.32 release was removing ByTree.pm.

	* In SkipID.pm, the data-dictionary (%NODE_TYPES_EXTRA_DETAILS) for these
	Node types was updated: catalog, view_expr, routine_stmt, routine_expr; for
	most, it was to rename attributes in the search_paths; for 'catalog', it
	was to add attr_defaults.

	* Corresponding updates in SkipID.pm and en.pm with these user messages:
	SRTSID_N_SET_NREF_AT_NO_ID_MATCH, SRTSID_N_SET_ATS_BAD_ARGS.  In en.pm
	alone, also updated SRTSID_N_CR_NODE_TREE_NO_ARGS.  In all 3 cases, the
	updates concerned the variable list, which automatically contains the 
	current Node type and ID due to an earlier Routine.pm change.

	* In t_SQL_Routine_SkipID.pm, replaced 'expr_type' attributes with
	'cont_type' attributes.  Also renamed these attributes: view_col ->
	set_result_col, call_sfunc -> valf_call_sroutine, src_col -> valf_src_col,
	lit_val -> valf_literal.

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

	* This release had no other changes.

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

	* SQL-Routine Release 0.47.

	* New code file versions are: Routine.pm v0.47 and en.pm v0.17.

	* This release mainly serves to merge two previously distinct modules into
	one; SQL::Routine::ByTree has been merged into SQL::Routine, and no longer
	exists as its own entity.  However, the code that was ByTree.pm has been
	rewritten in the process.  Similarly, SQL::Routine::ByTree::L::en was
	merged into SQL::Routine::L::en.  The details of this merger are given
	below, but simply in terms of new functionality being added to Routine.pm.

	* Renamed the *parent_node*() methods to *pp_node*(); this affected
	Routine.pm and en.pm and the test suite.

	* Added new Node method get_first_candidate_pp_node_attribute_name().

	* Added 7 new functions or methods that should assist more rapid
	development of code that uses SQL::Routine, at the cost that the code would
	run a bit slower (SQL::Routine has to search for info behind the scenes
	that it would otherwise get from you).  These methods are implemented as
	wrappers over other SQL::Routine methods, and allow you to accomplish with
	one method call what otherwise requires about 4-10 method calls, meaning
	your code base is significantly smaller (unless you implement your own
	simplifying wrapper functions, which is recommended in some situations).
	These 2 can be invoked on any class name or object: build_lonely_node(),
	build_container().  These 5 can be invoked only on an object: build_node(),
	build_child_node(), build_child_nodes(), build_child_node_tree(),
	build_child_node_trees(); the last 2 of these 5 correspond the most to the
	old 4 ByTree.pm create_[child_]node_tree[s]() methods, and take all of the
	same input that they did.  Added 6 new message keys to en.pm that
	correspond to the 7 added methods.

	* Corrected a bug in Routine.pm where the 'catalog_instance' Node attribute
	'server_domain' was mis-named 'server_scalar_domain'.

	* Small corresponding change in Language.pod and Routine.pm: Added a
	distinct value constraint on each of "[table|view]_field.row_field"; this 
	was the only change to Language.pod.

	* Split up the tester module t_SQL_Routine.pm into two more specialized
	files, which SQL_Routine.t invokes: t_SRT_Circular.pm, t_SRT_Verbose.pm;
	none of the module test code itself was changed during the split.

	* Added a third tester module t_SRT_Terse.pm, which SQL_Routine.t invokes;
	it is similar in structure to t_SRT_Verbose.pm but it exclusively uses the
	new build_*() to produce the model.  This tester module is a modified 
	version of the t_SQL_Routine_ByTree.pm that came with SQL::Routine::ByTree.
	The new test count goes from 1..9, up from 1..6.

	* The code added to Routine.pm wasn't identical to that removed from
	ByTree.pm; these are the main changes:  1. ByTree.pm called
	assert_deferrable_constraints() immediately after each Node was built;
	Routine.pm does not.  2. ByTree.pm always put the new Nodes in a Container
	(or tried to and could possibly have died on a Perl error); Routine.pm only
	does in specific situations.  3. ByTree.pm never generated Node ids;
	Routine.pm does in specific situations.

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

	* SQL-Routine Release 0.46.

	* New code file versions are: Routine.pm v0.46 and en.pm v0.16.

	* This is a major release, with multiple significant data-dictionary,
	documentation, and test suite changes, but almost no changes to the code
	proper.  Most changes were in Routine.pm, Language.pod, and
	t_SQL_Routine.pm.  A few changes were made to en.pm or API_C.pod.

	* Renamed all Node-ref attributes that are primary-parent candidates so
	that their names start with "pp_".  Also renamed any related variable names
	and property names and message key names in a similar fashion.  The Node
	property 'p_node_atnm' is now 'pp_node_atnm', in both Routine.pm and
	API_C.pod; that was the only change to API_C.pod.  Six message keys were
	renamed in Routine.pm and en.pm; that was the only change to en.pm.  Also
	changed the order of a few primary-parent attribute declarations so that
	any which are self-references always appear first in the list.

	* Eliminated the deprecated 'view_hierarchy' Node type; you should use
	the already supported SQL:2003 recursive correlated subqueries instead.

	* Replaced most of the 'view_type' enumerated type values; the new list is
	[ALIAS, JOINED, GROUPED, COMPOUND, INSERT, UPDATE, DELETE]; the old list
	was [MATCH, SINGLE, MULTIPLE, COMPOUND, SUBQUERY, RECURSIVE].  Removed the
	'view' Node attribute 'match_all_cols'.  Added the 'view' Node attribute
	'recursive'.  Added the new Node type 'view_compound_elem', which specifies
	operands for compound views explicitly, just as 'view_join' explicitly gave
	joined view operands; as a result of this change, it is now possible for a
	compound view to have subqueries; the subquery-defining views are not
	included as compound operands implicitly due to their presence.

	* Reversed all code and documentation changes made by release 0.44 that
	removed the 'elements' level-2 pseudo-Node; it is now useful again.  The
	restored documentation was also cleaned up.

	* Renamed the 'simple_data_type' enumerated type to 'simple_scalar_type'.

	* Split the 'domain' Node type into the 'scalar_data_type' and
	'scalar_domain' Node types; 'scalar_data_type' Nodes are the same as the
	old 'domain' Nodes (complete with '*_opt' child Nodes) except that they
	live directly under 'elements', and not other Nodes; each 'scalar_domain'
	Node (optional) simply declares a schema object that is defined by a
	'scalar_data_type' Node, and can live where the old 'domain' Nodes lived. 
	As a result of this change, you now can choose whether each individual data
	type becomes a named schema object of its own or not.  Updated any other
	Node type attributes that referenced 'domain' Nodes so that each one can
	choose whether to reference a 'data_type' or 'domain' Node.

	* Updated most Node types with new or changed attributes so that they are
	now almost as saavy with collection data types as they are with scalar data
	types.  Routine variables and arguments and return values can now properly
	define all of these container types: SCALAR, SC_ARY, ROW, RW_ARY.  As can
	routine statements and expressions, and view expressions, and correlated
	view arguments.  Added 3 new Node types 'row_data_type' (with child
	'row_data_type_field') and 'row_domain'.  The general features and living
	arrangements of the 'row_*' Node types correspond to the 3 'scalar_*' Node
	types.  Most Node types that referenced domains before now reference the
	row type definitions.

	* Changed how the core column definitions for tables and views are done;
	now a 'row_data_type' will be created for each distinct table and view,
	which the 'table' or 'view' Node references in a new attribute-pair; this
	row_data_type declares the names and scalar data types for a table's or
	view's complete column set.  All other table or view related Node types now
	reference 'row_data_type_field' Nodes instead of '[table|view]_col' Nodes,
	since they are the core column definitions now.  Additional details for
	columns are still stored in reduced versions of the old two Node types,
	which have been renamed to '[table|col]_field'; these reduced Node types
	are no longer mandatory, and only need to be used for their added value. 
	All other Node types and attributes named '[*_|]col[|_*]' were renamed to
	'[*_|]field[|_*]', as were any similarly named code variables or functions.

	* Updated the 'view_src[|_field]' Nodes so that you now have 5 options for
	sources rather than 2; a source can match a table or a view as before, or
	it can match a local routine arg or var or correlated view arg that has a
	ROW or RW_ARY type; all 5 of these are conceptually a row set.

	* Changed how standard views for 'SELECT' and 'INSERT' statements are
	defined; now every row is selected or inserted as a single unit, either
	into or from row variables that are declared with the same 'row_data_type'
	as the view; the 4 new 'view' Node attributes
	'[set|ins]_p_routine_[arg|var]' say where to either select into or insert
	from.  Renamed the standard function 'SELECT_INTO' to 'SELECT'; the
	'SELECT' and 'INSERT' standard functions are overloaded to select or insert
	either a single row or a full rowset; what they do is controlled by the
	container type of the aforementioned source/target variable that is
	associated with the view; a 'ROW' will cause a single row, while a 'RW_ARY'
	will cause multiple rows.  The way that views for 'UPDATE' or 'DELETE'
	statements work is unchanged; they continue to be controlled through scalar
	variables associated with the views in their 'SET' or 'WHERE' SQL clauses.
	The 2 view_field attributes that were used by "select into" are now gone.

	* Renamed any table index attributes and related variables from
	'[*_|]ind[|_*]' to '[*_|]index[|_*]'.

	* Renamed the 'view_join' attribute 'join_type' to 'join_op'.

	* Multiple updates to t_SQL_Routine.pm.  All of the domain declarations
	were replaced with data-type declarations.  The table declaration now has a
	row_data_type declaration split out from it.  The "fetch_all_persons"
	routine now does an ordinary SELECT and returns a RW_ARY, rather than the
	more complicated process of declaring, opening, and returning a CURSOR;
	that is more like how people would often accomplish the task in real life. 
	The "insert_a_person" also had a lot of changes, where it lost about half
	of its size; the new version takes a single ROW argument instead of four
	SCALAR arguments, and the new INSERT built-in takes that as a single unit. 
	Mostly correspondence to all the attribute name changes, besides.  The
	SYNOPSIS in Routine.pm also had similar changes.

	* Cleaned up the LANGUAGE CONCEPT STRUCTURE in Language.pod to remove
	and/or correct some redundant details.  Removed a large chunk of antiquated
	documentation from the 'view_expr' Node type.  Also, some other small
	documentation cleanups in Language.pod and Routine.pm.

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

	* SQL-Routine Release 0.45.

	* New code file versions are: Routine.pm v0.45.

	* This release saw multiple data-dictionary, documentation, and test suite
	changes, but zero changes to the code proper.  All changes were in
	Routine.pm, Language.pod, and t_SQL_Routine.pm.  No changes were made to
	en.pm or API_C.pod.

	* In Routine.pm, rewrote the DESCRIPTION documentation.  Specifically, all
	but the first paragraph of the old DESCRIPTION was moved into a new section
	titled MATTERS OF PORTABILITY AND FEATURES.  The new DESCRIPTION is
	completely new, and better describes the purpose, features, strengths, and
	distinctiveness of this module, than the old documentation did.

	* Multiple corresponding data-dictionary changes in Language.pod and
	Routine.pm.  Added new 'routine_context' Node type that is conceptually a
	special-purpose 'routine_arg'; they are optional, and each 'routine' can
	have only one.  Added new 'standard_routine_context' enumerated type which
	is to standard routines what the new Node type is for user-defined
	routines.  Updated the existing standard routine specs to separate the
	'context' and 'args'.  Added new Node attributes to [view_arg,
	routine_stmt, routine_expr] so that the new 'context' for standard or
	user-defined routines can be referenced.  Added related constraints.

	* Changed the nature of how CONN/CONN_CX (db connection context) is
	declared, used, and changed, so that it is like CURSOR/CURSOR_CX.  Now,
	most details of a db connection context are defined when the variable that
	holds it is declared.  A CONN now has two distinct states, being 'open' or
	'closed', which it must be explicitly set to using CATALOG_OPEN() and
	CATALOG_CLOSE(); a CONN is no longer implicitly open simply by its
	existence; a brand new CONN variable starts out closed.  As a result of
	this change, you can now declare a connection context 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 CONN, rather than
	having to make a new CONN for each time (it is also now easier to represent
	cached database connections).

	* Updated the 'container_type' enumerated type to add new list elements:
	ROW, SC_ARY, RW_ARY.  These correspond to commonly used composite data
	types.  A 'ROW' corresponds to the SQL:2003 'ROW' and is a collection of
	named and typed scalar values; it is like a single table row, or a Perl
	hash.  Both 'SC_ARY' and 'RW_ARY' correspond to the SQL:2003 'ARRAY'; the
	first is an ordered list of 'SCALAR'; the second, an ordered list of 'ROW'.
	The rest of SQL::Routine is not yet updated to take advantage of the new
	types; that should happen in release 0.46.

	* Renamed all occurances of [LOGIN_USER|login_user] to
	[LOGIN_NAME|login_name]; this affects the CATALOG_OPEN() srt and these 
	Node types: catalog_instance, catalog_link_instance.

	* For all Node types that have a 'name' attribute, except 'user', that
	attribute is now always-mandatory.  In this release, that affects only
	these Node types (the rest were MA previously): catalog, application,
	data_storage_product, data_link_product, catalog_instance,
	application_instance.

	* Fixed bugs in Routine.pm where Node attribute types did not match their
	Language.pod documentation: table_col.default_val is 'misc' (not 'cstr');
	routine_expr.valf_literal is 'misc' (not 'cstr').

	* In Language.pod, added paragraph for the view_arg Node that explains
	correlated vs uncorrelated subqueries.  Also updated the features list. 
	Also updated the documented meaning of the table_col's "mandatory" attr.

	* Multiple updates to t_SQL_Routine.pm.  Split the user-defined routine
	"open_db_conn" into itself and "declare_db_conn", added "close_db_conn". 
	Most other changes correspond to the the above-mentioned feature changes,
	such as context Nodes and CONN changes.  More Nodes now have their 'name'
	set.  Also rearranged the order in which a few Node attributes are set, to
	match the order they appear within the Node.  The SYNOPSIS in Routine.pm 
	also had a few similar changes, but most of those were small.

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

	* SQL-Routine Release 0.44.

	* New code file versions are: Routine.pm v0.44.

	* This is a major release, with multiple significant data-dictionary,
	documentation, and test suite changes, but almost no changes to the code
	proper.  All changes were in Routine.pm, Language.pod, and
	t_SQL_Routine.pm.  No changes were made to en.pm or API_C.pod.

	* Added 4 new enumerated value types: container_type, exception_type,
	standard_routine, standard_routine_arg.  Removed 6 old enumerated value
	types: basic_expr_type, standard_func, basic_var_type, basic_stmt_type,
	standard_proc, command_type.  The 4 new types are mostly recombined
	replacements for the old 6 ones, though some of the old were simply
	superfluous.  exception_type is completely new.  container_type corresponds
	to basic_var_type plus the return-values documentation section in
	command_type plus the 'LIST' of basic_expr_type.  standard_routine is
	mostly the 3-way combination of command_type, standard_proc, standard_func,
	plus 'CAST' and 'RETURN' of basic_[expr|stmt]_type.  The majority of
	basic_[expr|stmt]_type was simply dropped since the info they gave
	duplicated what could be known by reading other attributes in
	[view|routine]_expr Nodes, which mostly corresponded 1:1.

	* Removed the 'command' and 'command_arg' Node types, which were only meant
	to be a temporary stop-gap feature anyway.  Their functionality has been
	integrated into the standard 'routine[|*]' Nodes, which can now embed
	built-in routine calls for all kinds of functionality, including queries,
	DML, DDL, and connection management.

	* Eliminated the 'elements' level 2 pseudo-Node, which hasn't been used for
	awhile; only 4 are left: 'blueprints', 'tools', 'sites', 'circumventions'.

	* All built-in standard routines now take named arguments rather than
	positional ones, just like user-defined routines; they can now all be used
	in the same ways.  In addition, it is now standard practice for any
	built-in routine to indicate failure by throwing an exception; the routine
	is assumed to have succeeded if it doesn't do this.

	* All schema object types (domains, sequences, tables, views, routines) can
	now be defined as either server/database-side or application-side (the
	first 3 were added).  Defining a table on the application-side is now the
	official way to make a "temporary table"; there is no 'table' Node
	attribute for that.

	* There is now more detailed documentation for many built-in routines,
	including what their arguments are, side-effects of calling them, and
	exceptions they may throw.

	* Added the commonly used 'ANSEL' to the 'char_enc_type' enum list.

	* Added a 'single_schema' attribute to 'catalog' Nodes.

	* Many small clean-ups and standardization with the order of attribute
	Nodes.  Now, all primary-parent candidate attributes always appear at the
	top of the list, below 'id'; then comes the 'name' attribute if there is
	one; then come the other attributes, starting with any always-mandatory or
	'type' ones, and grouped by functional relation.  Renamed and regrouped
	most view_expr and routine_expr attributes; the ones indicating
	correspondence such as what cols or args to *set* or *pass to* go first,
	and the ones indicating where a value comes from are below them; the latter
	group all start with 'valf_' for "value from".  The routine_stmt Node was
	simplified, with some details stored in routine_expr Nodes instead.  A set
	of 8 new attributes in routine_expr, which start with 'actn_' (for "act
	on") are used mainly with former 'CREATE_' (etc) standard routines.  The 
	new attribute names should be more descriptive than the old ones.

	* In Routine.pm, updated Node.assert_deferrable_constraints() in how the
	"Local Attribute Dependencies List" constraints are implemented so that
	depended-on attributes of all 3 major types are handled with common code.

	* Rewrote major parts of the SYNOPSIS in Routine.pm so that it provides a 
	complete but simple working example, rather than just a few lines plus 
	a reference to another file.

	* Updated sigificant chunks of t_SQL_Routine.pm to give a more complete
	semblence of working examples.

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

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

	* A few other small changes and fixes.

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

	* SQL-Routine-Castaways Release 0.31.

	* This is the first version of the SQL-Routine-Castaways distribution,
	which is the result of merging the preexisting SQL-SyntaxModel-ByTree and
	SQL-SyntaxModel-SkipID distributions.  All modules were renamed to
	SQL::Routine::* from SQL::SyntaxModel::*, and the other files had similar
	renaming.  All name-related strings, both in code and documentation, were
	updated as follows: "SyntaxModel" -> "Routine", "SSM" -> "SRT".

	* New code file versions are: ByTree.pm v0.31, ByTree/L/en.pm v0.06, 
	SkipID.pm v0.31, SkipID/L/en.pm v0.06.

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

	* Aside from the name references, version numbers, dependencies, and
	following items, no changes were made to any code or documentation between
	SQL-SyntaxModel-[ByTree|SkipID]-0.30 and SQL-Routine-Castaways-0.31.

	* Updated the create[_child]_node_tree() methods in ByTree.pm and SkipID.pm
	in the following ways: 1. Removed the add_reciprocal_links() invocations,
	as that parent class method no longer exists (and isn't needed). 2. Renamed
	the test_deferrable_constraints() method calls to
	assert_deferrable_constraints(). 3. There are now two
	assert_deferrable_constraints() calls per method, one prior to child Nodes
	being created, and one after; the first call is wrapped in a try/catch
	which traps 'SRT_N_ASDC_CH_N_TOO_FEW_SET' exceptions.

	* Updated the test file t_SQL_Routine_ByTree.pm in the following ways: 1.
	Changed all routine_type attributes from ANONYMOUS to FUNCTION. 2. Set the
	attribute 'return_var_type' on all 'routine' Nodes. 3. Added a child
	routine_stmt Node beneath each 'routine' Node. 4. Moved the 'name'
	attribute of each 'view' Node in the output string to follow any
	primary-parent attributes.

	* Updated the test file t_SQL_Routine_SkipID.pm in the following ways: 1.
	Changed the 'name' attribute of the first 'view' Node so that it is not
	identical to the 'name' of a sibling 'table' Node.

	* For historical posterity, here is this distribution's file manifest:

		ChangeLog
		INSTALL
		lib/SQL/Routine/ByTree.pm
		lib/SQL/Routine/ByTree/L/en.pm
		lib/SQL/Routine/Castaways.pod
		lib/SQL/Routine/SkipID.pm
		lib/SQL/Routine/SkipID/L/en.pm
		Makefile.PL
		MANIFEST
		META.yml                                Module meta-data (added by MakeMaker)
		ReadMe
		t/lib/t_SQL_Routine_ByTree.pm
		t/lib/t_SQL_Routine_SkipID.pm
		t/SQL_Routine_ByTree.t
		t/SQL_Routine_SkipID.t
		TODO

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

	* SQL-Routine Release 0.43.

	* This is the first version of the SQL-Routine distribution under that
	name, which follows the official registration of SQL::Routine with the Perl
	5 Module List.  The core module has been renamed to SQL::Routine from
	SQL::SyntaxModel, its previous name; all similarly named modules and files
	were correspondingly renamed.  All name-related strings, both in code and
	documentation, were updated as follows: "SyntaxModel" -> "Routine", "SSM"
	-> "SRT", "SQLSM" -> "SQLRT", "sqlsm" -> "sqlrt".

	* New code file versions are: Routine.pm v0.43 and en.pm v0.15.

	* Updated external dependencies on Locale::KeyedText to v1.00.

	* Changed the NAME of Routine.pm to "Specify all database tasks with SQL
	routines" from "An abstract syntax tree for all types of SQL".

	* Aside from the name references, version numbers, and dependencies, no
	changes were made to any code or documentation between SQL-SyntaxModel-0.42
	and SQL-Routine-0.43.  A significant update to the main documentation is 
	planned for v0.44 which reflects the module's current functional domain.

	* For historical posterity, here is this distribution's file manifest:

		ChangeLog
		INSTALL
		lib/SQL/Routine.pm
		lib/SQL/Routine/API_C.pod
		lib/SQL/Routine/L/en.pm
		lib/SQL/Routine/Language.pod
		LICENSE
		Makefile.PL
		MANIFEST
		META.yml                                Module meta-data (added by MakeMaker)
		ReadMe
		t/lib/t_SQL_Routine.pm
		t/SQL_Routine.t
		TODO

	* Rewrote the TODO file so it actually lists some near-future plans.

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

	The next version of the Module List will list the following module:

	  modid:       SQL::Routine
	  DSLIP:       cdpOg
	  description: Specify all database tasks with SQL routines
	  userid:      DUNCAND (Darren Duncan)
	  chapterid:   11 (String_Lang_Text_Proc)
	  enteredby:   BDFOY (brian d foy)
	  enteredon:   Mon Oct  4 20:04:46 2004 GMT

	The resulting entry will be:

	SQL::
	::Routine         cdpOg Specify all database tasks with SQL routines DUNCAND

2004-09-13   Darren Duncan <perl@DarrenDuncan.net>

	* SQL-SyntaxModel Release 0.42.

	* New code file versions are: SyntaxModel.pm v0.42, en.pm v0.14.

	* Updated, corrected, and cleaned up several blocks of documentation in
	SyntaxModel.pm: STRUCTURE, BUGS, CAVEATS, SEE ALSO.  In Language.pod, these
	blocks were similarly worked on: the 'routine_type' enumerated type
	description, the NODE TYPES introduction, a 'user' Node type comment.

	* Changed the NAME of API_C.pod from "Describe the core C API for
	SQL::SyntaxModel" to "Describe the API for a C version of
	SQL::SyntaxModel".

	* This release is primarily a module design simplification, consisting of
	the removal of the distinct "At Home" Node evolution state; now there are
	only 2 distinct states, "Alone" and "Well Known".  The two remaining states
	have identical semantics to before, but there is now no intermediate state
	where a Node can both be in a container and not be return-linked to by
	other Nodes that it links to.  For all practical purposes, you can now just
	use the "Alone" state where you may have used "At Home" before, which is
	when an in-construction Node shouldn't have its existence known to the rest
	of the system.  All related changes were made in SyntaxModel.pm and en.pm,
	unless otherwise stated.  Further details of this change are listed next.

	* The method add_reciprocal_links() has had its functionality merged into
	the method put_in_container(); likewise, remove_reciprocal_links() has been
	merged into take_from_container().  The method are_reciprocal_links() was
	simply removed, since whether or not get_container() returns a value now
	has the same implications the removed method had.  There were 3 messages in 
	en.pm for those methods that were merged or removed.

	* Removed the 'links_recip' Node property, which is no longer needed.  Also
	removed the sqlsm_dt_node member 'links_recip' in the API_C.pod docs.  Any
	SyntaxModel.pm code which consulted the now-removed property when deciding
	to do something now consults whether the Node is in a Container instead.

	* Updated set_node_ref_attribute() and _clear_node_ref_attribute() to remove 
	one test and simplify two others; one en.pm message was removed.

	* The method move_before_sibling() had one input test updated and two others 
	merged; in en.pm, 3 messages were merged or removed.

	* Updated Node.assert_deferrable_constraints() to simplify a conditional.

	* Updated all documentation references to Node states and "At Home" to
	remove and adjust for the missing intermediate state.  Most updates were
	in: SYNOPSIS, NODE EVOLUTION STATES, and several method descriptions.

	* Updated t_SQL_SyntaxModel.pm to remove two add_reciprocal_links() calls.

	* Between the above changes, the file set had about 5K shaved from it.

	* Due to the removal of the *_reciprocal_links() methods, this release is
	not backwards compatible with any code that invoked them, which is
	basically all of it; to fix this, just remove or replace the invocations.

2004-09-09   Darren Duncan <perl@DarrenDuncan.net>

	* SQL-SyntaxModel Release 0.41.

	* New code file versions are: SyntaxModel.pm v0.41, en.pm v0.13.

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

	* Updated Language.pod and SyntaxModel.pm so that the 'view' Node attribute
	'name' now appears below all primary-parent candidate view attributes,
	rather than between them.  Corresponding change to the expected output in 
	t_SQL_SyntaxModel.pm, and in the SYNOPSIS of SyntaxModel.pm.

	* Updated Language.pod and SyntaxModel.pm to remove INTO from the view_part
	enumerated list; view_expr Nodes are no longer used to store these details,
	but rather view_col Nodes are (they have a 1:1 relation).  Moved the two
	Node attributes [set_routine_arg,set_routine_var] to the view_col Node type
	from the view_expr Node type.  Corresponding constraints changes.

	* Updated Language.pod and SyntaxModel.pm to remove ANONYMOUS from the
	routine_type enumerated list; you should now use PROCEDURE or FUNCTION for
	application-side routines instead, the latter especially for those whose
	main action is a SELECT.  Updated for 'routine' Nodes the local attribute
	dependency on routine_type by return_var_type so that the attribute can
	only be set for FUNCTION routines, and it is now always-mandatory for
	those.  Corresponding updates to the SYNOPSIS documentation of
	SyntaxModel.pm, and to the t_SQL_SyntaxModel.pm test suite.

	* Updated Language.pod and SyntaxModel.pm so that 'routine' Nodes can no
	longer have 'table' or 'view' primary parent Nodes; now each TRIGGER
	routine will instead have a 'schema' primary parent Node instead, just like
	PROCEDURE or FUNCTION routines do.  The 'routine' Node attributes 'table'
	and 'view' are now no longer primary-parent candidates, and they have been
	renamed to 'trigger_on_table' and 'trigger_on_view'.

	* Updated Language.pod and SyntaxModel.pm to add the Node ref attribute
	call_uproc_arg to routine_expr Nodes; now call_ufunc_arg is no longer
	overloaded to also store arguments to parent routine_stmt call_uprocs.

	* Updated Language.pod and SyntaxModel.pm to add the boolean attribute
	is_memory_based to data_storage_product Nodes, and to the Node type's
	"type" mutex group.  Also added the 3 [local_dsn, login_user, login_pass]
	cstr attributes to catalog_instance Nodes, so you have flexability to set 
	either those or the corresponding catalog_link_instance attributes.

	* Renamed the methods [Container|Node].[_]test_deferrable_constraints() to
	[Container|Node].[_]assert_deferrable_constraints(), which better describes
	how they behave.  Renamed corresponding user-text keys TEDC to ASDC.  Also
	added 2 new private methods: Node._assert_in_node_deferrable_constraints()
	and Node._assert_child_comp_deferrable_constraints(), split off from ASDC.

	* Partly rewrote almost all of the en.pm user-text so that the messages are
	more consistent and informative.  Now the Node Type and Node Id of the
	current Node is always given for exceptions generated by Node methods (the
	Id is blank if not yet set); this should make it a lot easier for
	developers to identify which Node is having a problem.  Also updated the
	message variable names to be more consistent, in en.pm and SyntaxModel.pm. 
	In SyntaxModel.pm, it is now just the private method _throw_error_message()
	which puts the NTYPE and NID into the variable list of the new Message; all 
	of the other methods that used to do this are now simplified to not do it.

	* Updated Language.pod to add 6 new head2 sections under NODE TYPES, one
	for each pseudo-Node.  These exist largely to store details given in terms
	of "child Nodes" about Node types that have pseudo-Node parents.  Added a 
	corresponding new %PSEUDONODE_TYPES config structure to SyntaxModel.pm.

	* Updated Language.pod and SyntaxModel.pm to add two new types of
	deferrable constraints called "Child Quantity List" and "Distinct Child
	Groups List", which are the first constraints that test a Node's validity
	by examining other Nodes (except for the constantly applied distinct-id
	constraint).  This conceptually replaces the "Unique Constraint List" which
	has been in Language.pod for a long time but was never implemented in
	SyntaxModel.pm.  All Language.pod changes were in the NODE TYPES main
	section intro plus per-Node sub-sections, and most SyntaxModel.pm changes
	were in the %NODE_TYPES and %PSEUDONODE_TYPES config structures plus the
	Node._assert_child_comp_deferrable_constraints() method.

	* Minor documentation updates: replace 'bind var(s)' with 'host param(s)'.

2004-09-01   Darren Duncan <perl@DarrenDuncan.net>

	* SQL-SyntaxModel-SkipID Release 0.30.

	* From now on, SQL::SyntaxModel::SkipID and its primary distribution will
	have identical version/release numbers, to help avoid public confusion as
	to which distribution releases contain which SQL::SyntaxModel::SkipID
	versions.  This distribution's Makefile.pl now uses "VERSION_FROM =>
	'lib/SQL/SyntaxModel/SkipID.pm'" rather than "VERSION => N".  As such,
	SkipID.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, SkipID.pm is now at v0.30, up from
	v0.14 in the previous release.

	* Other new code file versions are: en.pm v0.05.

	* Updated external dependencies on Locale::KeyedText to v0.06 and on
	SQL::SyntaxModel to v0.40.

	* Updated all user-text strings in 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.

	* Various small changes to ensure that SkipID.pm remains compatible with
	the latest SQL::SyntaxModel changes.  Also affirmed that SkipID.pm still
	passes the SQL::SyntaxModel test suite as a drop-in substitution for that
	module.  Also updated all SEE ALSO docs.

	* Renamed any calls on [with_all_nodes_]test_mandatory_attributes() to
	test_deferrable_constraints().

	* Updated _create_node_tree__do_when_parent_not_set() so it no longer
	throws an exception on failure to set a primary parent Node; the subsequent
	call to test_deferrable_constraints() in create_node_tree() would now
	perform the same assertion; removed the SSMSID_C_CR_NODE_TREE_NO_PRIMARY_P
	user message from en.pm.  Renamed the SSMSID_N_SET_AT_NREF_NO_ID_MATCH user
	message to SSMSID_N_SET_NREF_AT_NO_ID_MATCH.

	* Updated %NODE_TYPES_EXTRA_DETAILS in SkipID.pm for 'domain' Nodes so that
	there is no longer an 'attr_defaults' for 'char_enc'.  Before the change,
	SkipID.pm was adding a char_enc attribute to all domain Nodes, even those
	that were not the STR_CHAR; that behaviour was so very, very wrong.

	* Moved this distribution's t_*.pm file from the /lib directory to a new
	/t/lib directory, so that it doesn't pollute the user's install
	directories, and so the distribution is better organized on the whole.
	Added a "use lib 't/lib';" to SQL_SyntaxModel_SkipID.t in order to make the
	move work.  No changes to the tests themselves, except for any mentioned
	below here.  Updated the MANIFEST.

	* Updated t_SQL_SyntaxModel_SkipID.pm to transpose the 'domain' Node
	attributes 'num_precision' and 'num_scale'.  This actually corresponds to a
	SQL::SyntaxModel change made on 2004-04-10 with v0.16, but only just with
	v0.40 do SQL::SyntaxModel's constraints flag the SkipID.pm test data error.

	* Updated t_SQL_SyntaxModel_SkipID.pm to add 'char_enc' attributes to 6
	'domain' Nodes that needed them, since 'char_enc' no longer has a default
	value.  Also updated the expected output XML string to remove all of the
	'char_enc' from non-STR_CHAR domain Nodes.

2004-09-01   Darren Duncan <perl@DarrenDuncan.net>

	* SQL-SyntaxModel-ByTree Release 0.30.

	* From now on, SQL::SyntaxModel::ByTree and its primary distribution will
	have identical version/release numbers, to help avoid public confusion as
	to which distribution releases contain which SQL::SyntaxModel::ByTree
	versions.  This distribution's Makefile.pl now uses "VERSION_FROM =>
	'lib/SQL/SyntaxModel/ByTree.pm'" rather than "VERSION => N".  As such,
	ByTree.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, ByTree.pm is now at v0.30, up from
	v0.14 in the previous release.

	* Other new code file versions are: en.pm v0.05.

	* Updated external dependencies on Locale::KeyedText to v0.06 and on
	SQL::SyntaxModel to v0.40.

	* Updated all user-text strings in 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.

	* Various small changes to ensure that ByTree.pm remains compatible with
	the latest SQL::SyntaxModel changes.  Also affirmed that ByTree.pm still
	passes the SQL::SyntaxModel test suite as a drop-in substitution for that
	module.  Also updated all SEE ALSO docs.

	* Renamed any calls on [with_all_nodes_]test_mandatory_attributes() to
	test_deferrable_constraints().

	* Moved this distribution's t_*.pm file from the /lib directory to a new
	/t/lib directory, so that it doesn't pollute the user's install
	directories, and so the distribution is better organized on the whole.
	Added a "use lib 't/lib';" to SQL_SyntaxModel_ByTree.t in order to make the
	move work.  No changes to the tests themselves, except for any mentioned
	below here.  Updated the MANIFEST.

	* Updated t_SQL_SyntaxModel_ByTree.pm to transpose the 'domain' Node
	attributes 'num_precision' and 'num_scale'.  This actually corresponds to a
	SQL::SyntaxModel change made on 2004-04-10 with v0.16, but only just with
	v0.40 do SQL::SyntaxModel's constraints flag the ByTree.pm test data error.

2004-08-31   Darren Duncan <perl@DarrenDuncan.net>

	* SQL-SyntaxModel Release 0.40.

	* New code file versions are: SyntaxModel.pm v0.40, en.pm v0.12.

	* Many updates to Language.pod and SyntaxModel.pm and en.pm such that all
	of the deferrable constraints were rewritten; the scope of these
	constraints is still roughly the same, such that all validation tests
	performed on a Node restrict themselves to examining that same Node only
	(multi-Node tests are planned for v0.41), but they now test not only when
	each attribute should be valued, but also when each should *not* be valued.
	In SyntaxModel.pm, nearly all of the changes were in the
	Node.test_deferrable_constraints() method and the internal %NODE_TYPES
	configuration data structure, plus 3 of the static information functions. 
	In Language.pod, all of the changes were in the NODE TYPES main
	documentation intro section, plus its sub-sections for each Node type.  For
	each Node, the "Attribute List" was split into itself plus the "Exclusive
	Attribute Groups List" and the "Local Attribute Dependencies List" (no
	changes were made to "Unique Constraint List" or "Example List").  The MA
	(always-mandatory) flags for single attributes no longer appear on the same
	attributes that are either NODE_ID (id) or PP (primary-parent), where they
	are now redundant.  The MCEE flags were removed in favor of a much superior
	implementation in "Local Attribute Dependencies List".  The few MCR flags
	were removed as being redundant with the much more complete "Exclusive
	Attribute Groups List".  The recursive-parent attribute in %NODE_TYPES was
	removed due to being superfluous.  The 3 %NODE_TYPES keys for MA were
	merged into one.  All en.pm messages for TEDC were replaced.  Now all
	%NODE_TYPES constructs are array based, except for _AT_ ones.

	* Rewrote Container.test_deferrable_constraints() so that it now tests a
	Container's Nodes in the same order that they exist in the logical tree,
	meaning the same order that get_all_properties() fetches them, rather than
	in the apparently random order having all Nodes of a type done together. 
	As a result, you should have a much easier time in tracking down any input
	errors in your own code, or of predicting which of several existing errors
	will be reported first.  Part of the rewrite involved splitting the method 
	into itself and the private _test_deferrable_constraints().

	* Added 2 new attributes [set_routine_arg, set_routine_var] to view_expr
	Nodes, which are used by INTO clauses; the older [set_routine, set_routine]
	attributes no longer have a dual role that includes this; updated docs.

	* Renamed one miscellaneous message key in SyntaxModel.pm and en.pm.  Made
	a few other minor documentation fixes in SyntaxModel.pm.

	* Moved this distribution's t_*.pm file from the /lib directory to a new
	/t/lib directory, so that it doesn't pollute the user's install
	directories, and so the distribution is better organized on the whole. 
	Added a "use lib 't/lib';" to SQL_SyntaxModel.t in order to make the move
	work.  No changes to the tests themselves.  Updated the MANIFEST.

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

	* SQL-SyntaxModel Release 0.39.

	* New code file versions are: SyntaxModel.pm v0.39, en.pm v0.11.

	* Renamed all references of "bind variables" to "host parameters", since
	that is the official name for them in the SQL-2003 standard.

	* This release is primarily a reversal of most changes from release 0.36;
	it removes the dubious feature, and complicated implementing code, data,
	and documentation, where a Node-ref attribute could be defined to link to
	more than one type of Node, qualified by a nearby enumerated value
	attribute.  Corresponding to this, the "command" Node type has been split
	into itself and the new "command_arg" Node type; the latter has 8 separate
	"argument value" Node-ref attributes, only one of which is used per Node,
	and each of which is specific to one Node type.  These methods were
	simplified and/or reverted to remove the feature:
	expected_node_ref_attribute_type(), set_node_ref_attribute(),
	put_in_container(), test_deferrable_constraints().  The private method
	_resolve_variable_node_ref_attribute_type() was removed entirely.  Small
	SYNOPSIS update.  Removed feature refs from Language.pod, in the NODE TYPES
	section.  Removed 7 messages about the feature from en.pm.

	* Due to the Node split, this release is not backwards compatible with any
	code that used "command" Nodes with previous releases.  Also, this new
	release is less strict than the old one, but release 0.40 will fix that.

2004-08-16   Darren Duncan <perl@DarrenDuncan.net>

	* SQL-SyntaxModel Release 0.38.

	* From now on, SQL::SyntaxModel and its primary distribution will have
	identical version/release numbers, to help avoid public confusion as to
	which distribution releases contain which SQL::SyntaxModel versions.  This
	distribution's Makefile.pl now uses "VERSION_FROM =>
	'lib/SQL/SyntaxModel.pm'" rather than "VERSION => N".  As such,
	SyntaxModel.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, SyntaxModel.pm is now at v0.38, up
	from v0.24 in the previous release.

	* Other new code file versions are: en.pm v0.10.

	* Renamed both SyntaxModel.pm methods Node.test_mandatory_attributes() and
	Container.with_all_nodes_test_mandatory_attributes() to
	[Node|Container].test_deferrable_constraints(); the new name better
	describes their purpose.  Corresponding en.pm updates.	Updated the
	Container method so that it now skips over Nodes that are not in "Well
	Known" status.  Rewrote the POD descriptions for both methods also.

	* Added new Container.deferrable_constraints_are_tested() method and
	corresponding "deferrable constraints are tested" Container property which
	keeps track of whether any changes were made to a Container's Nodes since
	the last Container.test_deferrable_constraints() call.  This property is
	used to make the module faster in the face of redundant calls to the
	test_def*() method; you can now place SSM data validation test calls for
	safety all over your program without seeing a corresponding performance
	hit.  Updated about a dozen other methods to read or set this property.

	* Other minor documentation updates.

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

	* SQL-SyntaxModel Release 0.37.

	* Updated external dependencies on Locale::KeyedText to v0.06.

	* 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 Language.pod and SyntaxModel.pm (now v0.24) and en.pm (now
	v0.09).  Updated the 'command' Node type (and the command_type enumerated
	list) so that it can now possibly take anywhere from zero to two
	command_args, depending on the command_type; renamed Node attribute
	'command_arg' to 'command_arg_1' and added 'command_arg_2'; the 2 new
	attributes are conditionally mandatory, the old 1 was always mandatory;
	added 4 corresponding user messages.

	* Most 'DB_*' commands now take 'catalog_link' Nodes as their argument(s)
	rather than 'catalog' Nodes.  These commands now take zero arguments:
	DB_LIST, DB_CLOSE, DB_PING, TRA_OPEN, TRA_CLOSE, SCHEMA_LIST, USER_LIST;
	they know what to act on based on the context they are called in.  All
	'*_CLONE' and '*_MOVE' commands now take 2 arguments, both of the same
	type.  Updated Language.pod, SyntaxModel.pm, t_SQL_SyntaxModel.pm for this.

	* Documentation updates to the SYNOPSIS in SyntaxModel.pm, and the FEATURE
	SCOPE AND STANDARDS COMPLIANCE section in Language.pod, and a few other
	small changes.

	* Updated all user-text strings in 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.

	* Updated SQL::SyntaxModel::API_C to bring the sample C code in "CONTENT OF
	libSQLSM.h" partially up to date with the core distro files.  Rebuilt the
	sqlsm_dt_literal_type and sqlsm_dt_char_enc_type enum definitions so they
	are identical to those in Language.pod.  Updated the sqlsm_dt_node struct
	definition to match the attr names and orders in SyntaxModel.pm.  No other
	changes were made; the missing sqlsm_dt_container attrs are still missing.

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

	* SQL-SyntaxModel Release 0.36.

	* Updated Language.pod and SyntaxModel.pm (now v0.23).  Mainly this was to
	update the 'command_type' enumerated value list and the 'command' Node
	type. The 'command_arg' attribute of 'command' Nodes now has a major type
	of 'node ref' rather than 'literal'; SQL::SyntaxModel now enforces that
	'command_arg' is a valid Node, while before any integer was accepted, even
	if it didn't match a Node.  It also enforces the correct type of Node, 
	depending on what the 'command_type' is.

	* Updated SQL::SyntaxModel to add support for a Node ref attribute to be
	defined as flexible, accepting more than one type of Node for linking,
	depending on circumstances.  Currently, said Node ref attribute can be
	associated with an enumerated value attribute in the same Node, and be
	constrained based on its value. Generally speaking, the module's
	non-deferred input checks will allow a ref to (or id of) any type of Node
	to be set as the flexible attribute's value; it is mainly during the
	deferred input tests that the attribute will be constrained to exactly one
	Node type, as it is only then that we can guarantee the enumerated value we
	have to consult is also set.  These methods were updated to handle the new
	data-driven feature: expected_node_ref_attribute_type(),
	set_node_ref_attribute(), put_in_container(), test_mandatory_attributes();
	also, a new private method _resolve_variable_node_ref_attribute_type() was
	added.  Added three new messages to en.pm (now v0.08) for the new feature.  

	* Other minor fixes and updates were made to code and documentation.

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

	* SQL-SyntaxModel-SkipID Release 0.29.

	* Updated external dependencies on Locale::KeyedText to v0.04 and on
	SQL::SyntaxModel to v0.22.

	* This release is a small maintenance update to ensure that SkipID.pm (now
	v0.14) remains compatible with the latest SQL::SyntaxModel changes.  Most
	of the changes are in the test suite's set of input data and expected
	output data, but some changes were in the NODE_TYPES_EXTRA_DETAILS constant
	data in SkipID itself.  Beyond that, SkipID's API is identical to before.

	* Removed class property 'CPROP_HIGH_IDS' because it is now redundant with
	a new SQL::SyntaxModel feature; SkipID.pm code which used to set the old
	property was removed, and code which used to read it now calls
	SQL::SyntaxModel's get_next_free_node_id() method instead.  Changed methods
	are: Container.new(), Container.create_node_tree(),
	Node.create_child_node_tree().

	* Removed the long CONTRIVED EXAMPLE documentation section from SkipID.pm,
	which was redundant with the content of the test script/module files
	anyway, and seriously bloated the module.  Also updated the SYNOPSIS 
	documentation to point users to the script/module files for code examples, 
	rather than the now-removed documentation.  No other docs changes.

	* Following the above changes, SkipID.pm is now 38% smaller than before, 
	going from 45K down to 28K.

	* Added a 5th test to the test suite that explicitely makes sure that all 
	the mandatory attributes in the generated model are set.  SkipID.pm is 
	supposed to do this internally, but the test checks in case it doesn't.

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

	* SQL-SyntaxModel-ByTree Release 0.29.

	* Updated external dependencies on Locale::KeyedText to v0.04 and on
	SQL::SyntaxModel to v0.22.

	* This release is a small maintenance update to ensure that ByTree.pm (now
	v0.14) remains compatible with the latest SQL::SyntaxModel changes.  Most
	of the changes are in the test suite's set of input data and expected
	output data.  Beyond that, ByTree's API is identical to before.

	* Removed the long CONTRIVED EXAMPLE documentation section from ByTree.pm,
	which was redundant with the content of the test script/module files
	anyway, and seriously bloated the module.  Also updated the SYNOPSIS 
	documentation to point users to the script/module files for code examples, 
	rather than the now-removed documentation.  No other docs changes.

	* Following the above changes, ByTree.pm is now 68% smaller than before, 
	going from 31K down to 10K.

	* Added a 5th test to the test suite that explicitely makes sure that all 
	the mandatory attributes in the generated model are set.  ByTree.pm is 
	supposed to do this internally, but the test checks in case it doesn't.

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

	* SQL-SyntaxModel Release 0.35.

	* Updated external dependencies on Locale::KeyedText to v0.04.

	* Updated Language.pod and SyntaxModel.pm (now v0.22).  Changed the
	position of 'CAST' in the basic_expr_type enumerated list.  Updated the
	'view_expr' and 'routine_expr' Nodes to move the 'domain' attribute to just
	above the 'lit_val' attribute.  Also, 'domain' is now mandatory for
	'expr_type' of ['LIT', 'CAST'], rather than just 'CAST'.  As a result of
	this change, external SQL generating code now has the necessary info for
	how to properly quote or escape literal values being inserted into SQL.

	* Updated SyntaxModel.pm to add a new "next free node id" hash ref
	Container property.  Added new Container method get_next_free_node_id() to
	fetch the property.  Updated the Node methods set_node_id() and
	put_in_container() to update the property.  The new method can be used as a
	convenient sequence generator for new Node Ids; one suggested time for
	using it is when building a SQL::SyntaxModel by scanning a database schema.
	Added two new messages to en.pm (now v0.07) for the new method.  Updated
	the test suite in t_SQL_SyntaxModel.pm to use the new sequence generator,
	thereby simplifying the test code.  Corresponding SSM SYNOPSIS update.

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

	* SQL-SyntaxModel Release 0.34.

	* Updated Language.pod and SyntaxModel.pm (now v0.21).  Split the single
	'view' attribute 'c_merge_type' into 'compound_op' and 'distinct_rows'; the
	latter can be used with any view type.  Changed the values list of the
	compound_operator enumerated type from [DISTINCT, ALL, UNION, INTERSECT,
	EXCLUSIVE, EXCEPT] to [UNION, DIFFERENCE, INTERSECTION, EXCLUSION].

	* Added support for OLAP extensions, whose details are stored in
	'view_expr' Nodes associated with a group-by clause.  Added these 3
	'standard_func' enumerated values: [GB_SETS, GB_RLUP, GB_CUBE].  Added
	'LIST' to the 'basic_expr_type' enumerated list.

	* Added "routine_type" enumerated value "BLOCK" and removed the two values
	[LOOP, CONDITION].  Added "basic_stmt_type" enumerated values [BLOCK,
	RETURN] and removed "LOGIC" (plus documentation re DECLARE, SET).  Removed
	"standard_proc" enumerated values "RETURN" (redundant with a basic type),
	and "ROUTINE" (likewise redundant); added 3 values [LOOP, CONDITION,
	LOGIC]; split list in two, as the second part isn't rigorously defined yet.  
	Renamed "routine_stmt" Node attribute 'c_routine' to 'block_routine'.

	* Renamed 'routine' boolean attr 'trigger_per_row' to 'trigger_per_stmt';
	its meaning is now reversed, and 'per row' is now the default action.

	* Small updates to t_SQL_SyntaxModel.pm that keep the tests compatible with 
	the aforementioned changes, and to SQL::SyntaxModel's SYNOPSIS.

	* A few other small documentation fixes or updates.

2004-05-20   Darren Duncan <perl@DarrenDuncan.net>

	* SQL-SyntaxModel Release 0.33.

	* Updated Language.pod and SyntaxModel.pm (now v0.20) to remove all traces
	of the 'view_context' enumerated value list, as well as the same-named
	attribute in 'view' Nodes.  These were long known as redundant, and now they 
	are gone.  References to 'view_context' were also purged from the test suite, 
	and SyntaxModel.pm's SYNOPSIS.

	* Split the existing SYNOPSIS in SyntaxModel.pm beneath 2 sub-headings
	(head2), the first having the Perl code examples and the second having the
	XML dump of a model.  Then added a largeish third sub-section which
	demonstrates what actual SQL statements can be generated from parts of a
	model, including multiple variants of CREATE and UPDATE statements.  I hope
	that this will help ground my otherwise abstract documentation in reality,
	making SQL::SyntaxModel easier to adopt for use.  This update was inspired
	by Jarrell Dunson, who wrote me asking for examples of how to use
	SQL::SyntaxModel.

2004-05-19   Darren Duncan <perl@DarrenDuncan.net>

	* SQL-SyntaxModel Release 0.32.

	* Multiple corresponding updates in Language.pod, SyntaxModel.pm (now
	v0.19), and en.pm (now v0.06), mainly to better enforce data correctness.

	* Updated SyntaxModel.pm (and en.pm) to correct a long-standing bug where
	users were not prevented from creating circular virtual reference chains
	between Nodes, such as "A is the child of B and B is the child of A".
	Previously, users could create such arrangements whereby any code that
	wanted to traverse the Node tree (such as to generate XML) would have gone
	into an infinite loop, crossing the same Nodes repeatedly.  To fix the bug,
	these "setter" Node methods were updated to throw an error exception when
	users try to create a circular reference: set_node_ref_attribute(),
	set_parent_node_attribute_name(); also added a comment to
	put_in_container() which says why no such test is needed there; added a
	related comment to add_child_node().  Added 2 related messages to en.pm.
	The corresponding BUGS documentation POD was removed from SyntaxModel.pm.

	* Corresponding to the above change, a new method
	test_circular_ref_prevention() was added to t_SQL_SyntaxModel.pm, and 2 new
	numbered tests that use it were added to SQL_SyntaxModel.t.

	* Updated SyntaxModel.pm to enforce conditionally-mandatory (MC*)
	constraints on Node attributes that were long described in Language.pod.
	Previously, only the always-mandatory (MA) constraints were enforced, and
	lots of common omissions were allowed through unchecked.  Some new MC-type
	constraints were also added to Language.pod and SyntaxModel.pm.  There are
	now 3 main types of MC tests, which are 'MCEE', 'MCR' and 'PP'; see
	Language.pod (top of NODE TYPES) for descriptions.  To implement the
	change, added some code to the test_mandatory_attributes() method, and
	added a large amount of data which the new code uses to the %NODE_TYPES
	hash.  Note that, as before, all mandatory-value constraints are
	deferrable, and they are only enforced if you call the
	test_mandatory_attributes() method.  Added 8 related messages to en.pm and
	updated 3 others.  A few related fixes in the test suite.

	* The 'routine_expr' attributes 'src_[arg/var]' were renamed to
	'routine_[arg/var]' so they match their 'view_expr' counterparts.

	* A variety of other minor code/data/docs bug fixes or changes were made.

	* Since the extra validation adds considerably more work to the otherwise
	same interface, I thought some speed comparisons were in order.  These
	effectively time the running of the test suite 1000 times.  'MakeAndBreak'
	builds a new Container full of Nodes and then destroys it; it does not
	invoke the deferrable tests. 'TestMandatory' takes a single identical
	pre-stuffed Container and invokes the deferrable tests.  'ConvertToXML'
	takes an identical Container and dumps it to XML.

	Results for SQL-SyntaxModel-0.31:

		Benchmark: timing 1000 iterations of MakeAndBreak, TestMandatory, ConvertToXML...
		MakeAndBreak: 23 wallclock secs (23.23 usr +  0.00 sys = 23.23 CPU) @ 43.05/s (n=1000)
		TestMandatory:  2 wallclock secs ( 2.01 usr +  0.00 sys =  2.01 CPU) @ 497.51/s (n=1000)
		ConvertToXML: 16 wallclock secs (15.56 usr +  0.00 sys = 15.56 CPU) @ 64.27/s (n=1000)

	Results for SQL-SyntaxModel-0.32:

		Benchmark: timing 1000 iterations of MakeAndBreak, TestMandatory, ConvertToXML...
		MakeAndBreak: 32 wallclock secs (32.28 usr +  0.00 sys = 32.28 CPU) @ 30.98/s (n=1000)
		TestMandatory:  8 wallclock secs ( 7.57 usr +  0.00 sys =  7.57 CPU) @ 132.10/s (n=1000)
		ConvertToXML: 16 wallclock secs (15.70 usr +  0.00 sys = 15.70 CPU) @ 63.69/s (n=1000)

	To explain the results: The new circular reference prevention code makes
	'MakeAndBreak' about 1/3 slower; it could probably stand for some
	optimization later.  All the mandatory-value checks only affect
	'TestMandatory', which now takes about 4 times as long.  'ConvertToXML' is
	the same as before, and none of the changes should affect it.  Also, there 
	were no detectable memory leaks in both versions.

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

	* SQL-SyntaxModel Release 0.31.

	* Multiple corresponding updates in Language.pod and SyntaxModel.pm (now
	v0.18) that are partly of the re-ordering type.  Some are incompatible.

	* Now 'domain' Nodes are catalog schema objects like tables or sequence
	generators; they have 'schema' Nodes as their primary parents, and they
	exist in the 'blueprints' portion of the Node tree rather than 'elements'.
	As a result of this change, you can generate schema-specific named domains
	rather than just inlining their data type definitions in such places as
	table column definitions.  Domain-related documentation has also been moved
	to a location further down, just above that for sequence generators.

	* Removed the 'trigger' Node type and merged its attributes into the
	'routine' Node type.  Now routines that are triggers can be direct child
	Nodes of tables or views (triggers on views were not supported before).  
	Added new enumerated type 'basic_trigger_event' that is used by the new 
	'routine' in place of six boolean flags that the old 'trigger' used.  
	The old solution let you write a trigger once and have it run under 
	multiple circumstances; the new solution requires you to pick just one 
	event (eg before insert), as SQL-2003 requires.

	* Added 'view_src_arg' Node type which allows named subqueries to be passed
	arguments when they are used in a view's "from" clause.  Also added 'FROM'
	to the 'view_part' enumerated value list, and added new attribute
	'view_src_arg' to 'view_expr' Nodes.

	* Added a set of command_type enumerated values for working with named 
	schemas and domains (list, add, remove, etc).

	* Split the 'privilege' Node into 'privilege_on' and 'privilege_for' Nodes;
	the second is a child Node of the first.  Added a few more attributes to
	'privilege_on' Nodes.  Added a few privilege_type enumerated values.

	* The 'name' attribute of "schema" and "view" Nodes is now mandatory.

	* Added curs_view attribute to routine_arg Nodes.  Added curs_for_update 
	attribute to routine_var Nodes.  With routine_stmt Nodes, renamed c_view 
	attribute to view_for_dml, and added curs_arg/var attributes.

	* Added comment by view_expr Nodes regarding the INTO clause.

	* Updated t_SQL_SyntaxModel.pm and the SYNOPSIS in SyntaxModel.pm to
	account for the move of 'domain' from 'elements' to 'schema', and the
	rename of 'c_view' to 'view_for_dml', and the now mandatory view names.

2004-05-01   Darren Duncan <perl@DarrenDuncan.net>

	* SQL-SyntaxModel Release 0.30.

	* This is a "middle of development" release that includes a large number of
	changes, some of which are only partially implemented.  It exists largely
	so that I can have a reliable backup for (and historical record of) the
	last 3 weeks of in-progress work.  Some changes made now are incompatible
	with 0.29, and likewise will be further changes to come in 0.31.

	* Multiple corresponding updates in Language.pod and SyntaxModel.pm (now
	v0.17) that are partly influenced by my close studying of the SQL-2003
	standard, and partly by my attempts to build a SQL generator.  

	* Updated documentation to say that the SQL-2003 standard is now the focus 
	of influence rather than SQL-1999 (or SQL-1992).

	* Expanded the support for temporal data types / domains.  The 2
	simple_data_type enumerated values of [DATETIME, INTERVAL] have become 5
	values of [DATM_FULL, DATM_DATE, DATM_TIME, INTRVL_YM, INTRVL_DT].  Also
	added new 'domain' Node attribute 'with_zone'.

	* Expanded the support for table join operators.  The 2 join_operator
	enumerated values of [EQUAL, LEFT] have become 5 values of [CROSS, INNER,
	LEFT, RIGHT, FULL] (last 3 are outer-joins, INNER is renamed from EQUAL).  
	As with before, there is no concept of a "natural" join at this level.

	* Expanded the view_part enumerated value list to include WINDOW and other
	matters for consideration.

	* Expanded the basic_expr_type enumerated value list to add CAST and SEQN.
	Added new attributes to "view_expr" and "routine_expr" Nodes named 'domain'
	and 'sequence' that are respectively used with CAST and SEQN.

	* Updated the standard_func enumerated value list in several ways.  Removed 
	the TO_* casting functions, which for now are replaced by the CAST basic 
	expression type.  Renamed NVL to COALESCE, EXP to POWER.  Added NOT_NULL, 
	ABS.  Removed MIN, MAX, AVG as non-aggregate functions.  Removed CROWID, 
	CROWNUM, CLEVEL, which will be replaced later.  Renamed the G* aggregate 
	functions to the same names minus the leading 'G'.  Added EXISTS.

	* Added documentation regarding the recursiveness of views.

	* The 'name' attribute of "routine" Nodes is now mandatory.

	* Other small documentation updates in the same two files.  For example, 
	"sequences" are now called "sequence generators".

	* No updates were made to the test suite since it did not test the portions
	of SQL::SyntaxModel that changed; the old suite still passes all its tests.

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

	* SQL-SyntaxModel Release 0.29.

	* Updated Language.pod and SyntaxModel.pm (now v0.16) to transpose the
	'domain' Node attributes 'num_precision' and 'num_scale'.  Up until now I
	was using 'scale' to mean the same thing that everyone else uses
	'precision' to mean, and vice-versa; now I am using the terms to mean the
	same things as is widely accepted.  Further updated the documentation for
	all 'num_*' attributes, removed any conditional mandatory constraints on
	them.  Made a small corresponding change in t_SQL_SyntaxModel.pm.

	* Updated the 'command_type' enumerated type to include a set of 'SEQU_*' 
	commands that look like the ones for 'TABLE_*', 'VIEW_*', 'ROUTINE_*'.  
	Other minor changes in Language.pod and SyntaxModel.pm.

2004-03-22   Darren Duncan <perl@DarrenDuncan.net>

	* SQL-SyntaxModel-SkipID 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 the first one to bear the name
	SQL-SyntaxModel-SkipID.  For historical posterity, this is its file manifest:

		- ChangeLog
		- INSTALL
		- lib/SQL/SyntaxModel/SkipID.pm
		- lib/SQL/SyntaxModel/SkipID/L/en.pm
		- lib/t_SQL_SyntaxModel_SkipID.pm
		- Makefile.PL
		- MANIFEST
		- META.yml                                Module meta-data (added by MakeMaker)
		- ReadMe
		- t/SQL_SyntaxModel_SkipID.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, SQL::SyntaxModel::SkipID is now v0.13 and
	SQL::SyntaxModel::SkipID::L::en is now v0.04.

	* A few other minor updates were made to several files.

2004-03-22   Darren Duncan <perl@DarrenDuncan.net>

	* SQL-SyntaxModel-ByTree 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 the first one to bear the name
	SQL-SyntaxModel-ByTree.  For historical posterity, this is its file manifest:

		- ChangeLog
		- INSTALL
		- lib/SQL/SyntaxModel/ByTree.pm
		- lib/SQL/SyntaxModel/ByTree/L/en.pm
		- lib/t_SQL_SyntaxModel_ByTree.pm
		- Makefile.PL
		- MANIFEST
		- META.yml                                Module meta-data (added by MakeMaker)
		- ReadMe
		- t/SQL_SyntaxModel_ByTree.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, SQL::SyntaxModel::ByTree is now v0.13 and
	SQL::SyntaxModel::ByTree::L::en is now v0.04.

	* A few other minor updates were made to several files.

2004-03-22   Darren Duncan <perl@DarrenDuncan.net>

	* SQL-SyntaxModel 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 the first one to bear the name
	SQL-SyntaxModel.  For historical posterity, this is its file manifest:

		- ChangeLog
		- INSTALL
		- lib/SQL/SyntaxModel.pm
		- lib/SQL/SyntaxModel/API_C.pod
		- lib/SQL/SyntaxModel/L/en.pm
		- lib/SQL/SyntaxModel/Language.pod
		- lib/t_SQL_SyntaxModel.pm
		- LICENSE
		- Makefile.PL
		- MANIFEST
		- META.yml                                Module meta-data (added by MakeMaker)
		- ReadMe
		- t/SQL_SyntaxModel.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, SQL::SyntaxModel is now v0.15 and
	SQL::SyntaxModel::L::en is now v0.05.

	* 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 having that name which
	contained the modules that became the SQL-Routine distribution, was
	released on CPAN.

2003-01-27   Darren Duncan <perl@DarrenDuncan.net>

	* Rosetta-0.02, the first version of a distribution having that name, was
	released on CPAN.  Early versions of the modules that became the
	SQL-Routine distribution were included.

2003-01-05   Darren Duncan <perl@DarrenDuncan.net>

	* DBIx-Portable-0.01, the only version of a distribution having that name,
	was released on CPAN.  Early versions of the modules that became the
	SQL-Routine distribution were included.

2002-11-12   Darren Duncan <perl@DarrenDuncan.net>

	* Began development on the modules which became the SQL-Routine
	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.
