2004-11-26 Darren Duncan * SQL-Routine Release 0.51. * New code file versions are: Routine.pm v0.51 and en.pm v0.21. * The primary purpose of this release is to revise the handling of Node Ids, such that every Node in a Container has an Id value that is distinct from every other Node in the Container, regardless of Node Type. Prior to this release, each Node's Id only had to be distinct among Nodes of the same Node Type. One side-effect of this change is that almost any external code base that uses SQL::Routine will need a few changes to avoid breaking after this update, especially if the code specifies a Node Id value for each new Node rather than using the generator functionality. Another side-effect is that you can now reference any Node by its Id only; you do not need to specify both a Node Type and a Node Id. * Removed all of the "Example List" documentation in the NODE TYPES sub-sections of Language.pod. They have become increasingly out-dated over time, and t_SRT_Terse.pm provides a nearly identical example set. This removal shaved about 17K from Language.pod, taking it down to about 145K. * Updated Routine.pm so that its NEXT_FREE_NID Container property is now just an integer, rather than a Hash of integers looked up by Node Type; the property name was also renamed to remove the trailing 'S'. Updated the following methods to handle the altered property correctly: Container.new(), Container.get_next_free_node_id(), Node.set_node_id, Node.put_in_container(). Simplified the get_next_free_node_id() method so it no longer takes a NODE_TYPE argument; also removed 2 en.pm messages that were used by that method, SRT_C_GET_NFNI_[NO_ARG|BAD]_TYPE. * Updated Routine.pm so that its ALL_NODES Container property is now just a Hash of Nodes looked up by Id, rather than a Hash of Hashes looked up by Node Type + Node Id. Updated the following methods to handle the altered property correctly: Container.new(), Container.destroy(), Container.get_node(), Node.set_node_id(), set_node_ref_attribute(), _set_node_ref_attribute__find_node_by_link_search_attr(), put_in_container(), take_from_container(). Simplified the get_node() method so it no longer takes a NODE_TYPE argument; also removed 2 en.pm messages that were used by that method, SRT_C_GET_NODE_[NO_ARG|BAD]_TYPE. Also altered the user text of these en.pm messages: SRT_N_SET_NODE_ID_DUPL_ID, SRT_N_PI_CONT_DUPL_ID. Minor update in API_C.pod to the sqlrt_dt_container struct definition documentation. * Minor update to set_surrogate_id_attribute() in Routine.pm. * Large updates to the expected XML output strings of t_SRT_Verbose.pm, t_SRT_Abstract.pm, t_SRT_Terse.pm; the count and types and relations of the Node sets are identical to before, but the "id" of almost every Node has changed. Minor code updates in t_SRT_Abstract.pm that remove the only 3 "id" value definitions. In t_SRT_Verbose.pm, minor code updates to the two get_next_free_node_id() invocations. Large code updates in t_SRT_Terse.pm where of "id" explicit values were replaced, and to one get_node() call. 2004-11-23 Darren Duncan * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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,'')" was replaced with "ref($obj) and UNIVERSAL::isa($obj,'')". Before the fixes, code that UNIVERSAL::isa() was supposed to guard would eventually die with the standard Perl error "Can't use string ('') 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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.