Changeset 20273 for ext

Show
Ignore:
Timestamp:
04/13/08 02:27:54 (9 months ago)
Author:
Darren_Duncan
Message:

ext/Muldis-Rosetta/ : part 2 of renaming Muldis DB to Muldis Rosetta - most in-file changes

Location:
ext/Muldis-Rosetta
Files:
12 modified

Legend:

Unmodified
Added
Removed

  • ext/Muldis-Rosetta/Changes

    r20270 r20273  
    1                                 Muldis::DB 
     1                              Muldis::Rosetta 
    22--------------------------------------------------------------------------- 
    33 

  • ext/Muldis-Rosetta/Makefile.PL

    r20264 r20273  
    55use inc::Module::Install prefix => '../../inc'; 
    66 
    7 name       ('Muldis::DB'); 
     7name       ('Muldis::Rosetta'); 
    88version    ('0.6.2'); 
    99abstract   ('Full-featured truly relational DBMS in Perl'); 

  • ext/Muldis-Rosetta/README

    r20262 r20273  
    1                                 Muldis::DB 
     1                              Muldis::Rosetta 
    22--------------------------------------------------------------------------- 
    33 
    … …  
    77 
    88This distribution features the Perl 5 or 6 (depending on which copy of this 
    9 README file you are reading) module named Muldis::DB (Full-featured truly 
    10 relational DBMS in Perl) and its support structure. 
     9README file you are reading) module named Muldis::Rosetta (Full-featured 
     10truly relational DBMS in Perl) and its support structure. 
    1111 
    12 Muldis DB has 2 co-developed versions, which are written in native Perl 5 
    13 and Perl 6 respectively, and which are distributed separately from each 
    14 other.  But while the 2 versions would be similar, they are explicitly not 
    15 intended to be drop-in substitutable for each other, as each would have 
     12Muldis Rosetta has 2 co-developed versions, which are written in native 
     13Perl 5 and Perl 6 respectively, and which are distributed separately from 
     14each other.  But while the 2 versions would be similar, they are explicitly 
     15not intended to be drop-in substitutable for each other, as each would have 
    1616some API differences that optimizes it for its host language.  The actual 
    1717Muldis D language specification document will be identical for both, 
    … …  
    3333DOCUMENTATION READING ORDER 
    3434 
    35 If you want to read all the Muldis DB documentation that exists now in 
     35If you want to read all the Muldis Rosetta documentation that exists now in 
    3636this distribution, I recommend doing so in this order: 
    3737 
    3838   1.       README 
    3939   2. (opt) Changes 
    40    3.       lib/Muldis/DB.pm 
    41    4.       lib/Muldis/DB/Interface.pm 
    42    5. (opt) lib/Muldis/DB/Validator.pm 
    43    6. (opt) lib/Muldis/DB/Engine/Example.pm 
    44    7.       lib/Muldis/DB/SeeAlso.pod 
     40   3.       lib/Muldis/Rosetta.pm 
     41   4.       lib/Muldis/Rosetta/Interface.pm 
     42   5. (opt) lib/Muldis/Rosetta/Validator.pm 
     43   6. (opt) lib/Muldis/Rosetta/Engine/Example.pm 
     44   7.       lib/Muldis/Rosetta/SeeAlso.pod 
    4545   8. (opt) TODO 
    4646 
    … …  
    4848 
    4949You may prefer the nicely HTML-formatted versions of the above, which are 
    50 available at "http://search.cpan.org/dist/Muldis-DB/". 
     50available at "http://search.cpan.org/dist/Muldis-Rosetta/". 
    5151 
    52 I also suggest the Muldis-DB-Cookbook distribution, when that is available. 
     52I also suggest the Muldis-Rosetta-Cookbook distribution, when that is 
     53available. 
    5354 
    5455KEEPING UP TO DATE 
    … …  
    5960 
    6061For those of you that are interested in the bleeding edge of development, I 
    61 have all parts of the Muldis DB project in one or more public 
    62 repositories. The Perl 5 Muldis DB project is in a Git repository whose 
    63 Git read-access url is "git://utsl.gen.nz/Muldis-DB" and whose Gitweb 
    64 information url is at "http://utsl.gen.nz/gitweb/?p=Muldis-DB".  The Perl 6 
    65 Muldis DB project is in a Subversion repository at 
    66 "http://svn.pugscode.org/pugs/ext/Muldis-DB/". 
     62have all parts of the Muldis Rosetta project in one or more public 
     63repositories. The Perl 5 Muldis Rosetta project is in a Git repository 
     64whose Git read-access url is "git://utsl.gen.nz/Muldis-Rosetta" and whose 
     65Gitweb information url is at "http://utsl.gen.nz/gitweb/?p=Muldis-Rosetta". 
     66The Perl 6 Muldis Rosetta project is in a Subversion repository at 
     67"http://svn.pugscode.org/pugs/ext/Muldis-Rosetta/". 
    6768 
    6869You can download slightly older versions of all of my modules from the 
    … …  
    7576"http://search.cpan.org/search?author=DUNCAND". 
    7677 
    77 The main CPAN search site url for Muldis DB for Perl 5 is 
    78 "http://search.cpan.org/dist/Muldis-DB/"; that is the url you should link 
    79 to presently if you want something to consider the "home page" of 
    80 Muldis DB; it is best to refer people there by default. 
     78The main CPAN search site url for Muldis Rosetta for Perl 5 is 
     79"http://search.cpan.org/dist/Muldis-Rosetta/"; that is the url you should 
     80link to presently if you want something to consider the "home page" of 
     81Muldis Rosetta; it is best to refer people there by default. 
    8182 
    8283You can download my oldest tarred and gzipped distributions from BACKPAN, 
    … …  
    8889 
    8990Several public email-based forums exist whose main topic is all 
    90 implementations of the Muldis D language, especially the Muldis DB project, 
    91 which they are named for.  They exist so that Muldis D / Muldis DB users 
    92 can help each other, or that help coming from Muldis D / Muldis DB 
    93 developers can be said once to many people, rather than to each 
     91implementations of the Muldis D language, especially the Muldis Rosetta 
     92reference implementation.  They exist so that Muldis D / Muldis Rosetta 
     93users can help each other, or that help coming from Muldis D / Muldis 
     94Rosetta developers can be said once to many people, rather than to each 
    9495individually.  All of these you can reach via 
    9596"http://mm.DarrenDuncan.net/mailman/listinfo". 
    9697 
    9798Alternately, you can purchase more advanced commercial support for various 
    98 Muldis D implementations, particularly Muldis DB, from its author by way of 
    99 Muldis Data Systems; see "http://www.muldis.com/" for details. 
     99Muldis D implementations, particularly Muldis Rosetta, from its author by 
     100way of Muldis Data Systems; see "http://www.muldis.com/" for details. 
    100101 
    101102FIN 

  • ext/Muldis-Rosetta/TODO

    r19337 r20273  
    1                                 Muldis::DB 
     1                              Muldis::Rosetta 
    22--------------------------------------------------------------------------- 
    33 
    44Following is a summary of things that still need doing.  It is specific to 
    5 the Muldis-DB core distribution only, and doesn't talk about things that 
    6 would go in other distributions.  (But, look at lib/Muldis/DB/SeeAlso.pod 
    7 for a list of other related distributions that should be created.) 
     5the Muldis-Rosetta core distribution only, and doesn't talk about things 
     6that would go in other distributions.  (But, look at 
     7lib/Muldis/Rosetta/SeeAlso.pod for a list of other related distributions 
     8that should be created.) 
    89 
    910The following list is loosely ordered by priority, but list items may 
    … …  
    6869* Applicable to the Perl 5 version only:  Consider lowering the Perl 
    6970version dependency to 5.6 from 5.8.1, so that other projects which may 
    70 become dependants of Muldis-DB and already work under 5.6 won't have to 
    71 force Perl core upgrades.  If this is done, the list of further 
     71become dependants of Muldis-Rosetta and already work under 5.6 won't have 
     72to force Perl core upgrades.  If this is done, the list of further 
    7273dependencies will doubtless increase to include some things bundled with 
    7374Perl 5.8, and/or Unicode may not work so well here.  Note that this may 

  • ext/Muldis-Rosetta/archives/OSCON2008SessionProposal.txt

    r20262 r20273  
    3131    This session introduces Muldis D, an industrial strength programming 
    3232    language with fully integrated database functionality, and shows how to 
    33     use the Muldis DB database access framework for Perl.  The session will 
    34     focus on a few of the features that I consider the most interesting and 
    35     unique, and ways users can solve their common database-using problems. 
     33    use the Muldis Rosetta database access framework for Perl.  The session 
     34    will focus on a few of the features that I consider the most 
     35    interesting and unique, and ways users can solve their common 
     36    database-using problems. 
    3637 
    3738    Muldis D provides access to the entire relational model of data, 
    … …  
    4647    understand, and is easier to auto-optimize or auto-parallelize. 
    4748 
    48     Muldis DB is a database access framework in native Perl 5 and Perl 6 
    49     versions (for Perl 6 it is also the *first* database tool).  It 
     49    Muldis Rosetta is a database access framework in native Perl 5 and Perl 
     50    6 versions (for Perl 6 it is also the *first* database tool).  It 
    5051    presents databases to Perl applications as shared libraries of routines 
    5152    and data that can be used and updated.  The normal way for Perl code to 
    52     use a database with Muldis DB is to invoke the database's stored 
     53    use a database with Muldis Rosetta is to invoke the database's stored 
    5354    routines (and prepared statements) as if those were Perl routines, with 
    5455    data being inserted and retrieved via the routine parameters. 
    5556 
    56     Muldis DB is designed for strong inter-DBMS portability, and provides a 
    57     deeper abstraction than the Perl DBI, such that a Perl application will 
    58     see all DBMSs as having the same query language (Muldis D by default), 
    59     rather than them having highly-incompatible dialects of SQL.  But while 
    60     most database abstractors or ORMs treat every DBMS as a stupid data 
    61     store - a strategy that can result in the user getting fewer features 
    62     and poorer performance than the original DBMS provided - Muldis DB 
    63     differentiates DBMSs according to their capability, and optimally 
    64     leverages their built-in features where at all possible, only emulating 
    65     missing features in Perl as a last resort.  Unlike other tools, Muldis 
    66     DB features the ability to translate SQL stored procedures (and by 
    67     extension most other SQL features).  Muldis DB also includes a 
    68     full-featured DBMS natively in Perl, and user queries are compiled into 
    69     Perl code rather than SQL for execution; this allows database-using 
    70     projects (and Muldis DB itself) to be fully tested or demonstrated in 
    71     the absence of a normal DBMS, easing their development. 
     57    Muldis Rosetta is designed for strong inter-DBMS portability, and 
     58    provides a deeper abstraction than the Perl DBI, such that a Perl 
     59    application will see all DBMSs as having the same query language 
     60    (Muldis D by default), rather than them having highly-incompatible 
     61    dialects of SQL.  But while most database abstractors or ORMs treat 
     62    every DBMS as a stupid data store - a strategy that can result in the 
     63    user getting fewer features and poorer performance than the original 
     64    DBMS provided - Muldis Rosetta differentiates DBMSs according to their 
     65    capability, and optimally leverages their built-in features where at 
     66    all possible, only emulating missing features in Perl as a last resort. 
     67    Unlike other tools, Muldis Rosetta features the ability to translate 
     68    SQL stored procedures (and by extension most other SQL features). 
     69    Muldis Rosetta also includes a full-featured DBMS natively in Perl, and 
     70    user queries are compiled into Perl code rather than SQL for execution; 
     71    this allows database-using projects (and Muldis Rosetta itself) to be 
     72    fully tested or demonstrated in the absence of a normal DBMS, easing 
     73    their development. 
    7274 
    7375    Muldis D is intended to qualify as a "D" language as defined by 
    … …  
    9193    proposal selection process, they are at 
    9294    http://search.cpan.org/dist/Muldis-D/ (language spec) and 
    93     http://search.cpan.org/dist/Muldis-DB/ (Perl 5 impl) respectively.  I 
    94     didn't know whether to put those urls in the Abstract or not, so they 
    95     are here instead. 
     95    http://search.cpan.org/dist/Muldis-Rosetta/ (Perl 5 impl) respectively. 
     96    I didn't know whether to put those urls in the Abstract or not, so 
     97    they are here instead. 
    9698 
    9799    This session is arguably both in the Databases and Perl topics; while I 

  • ext/Muldis-Rosetta/lib/Muldis/Rosetta.pm

    r20272 r20273  
    44########################################################################### 
    55 
    6 package Muldis::DB-0.6.2 { 
     6package Muldis::Rosetta-0.6.2 { 
    77    # Note that Perl code only exists at all in this file in order to help 
    88    # the CPAN indexer handle the distribution properly. 
    9 } # package Muldis::DB 
     9} # package Muldis::Rosetta 
    1010 
    1111########################################################################### 
    … …  
    1818=head1 NAME 
    1919 
    20 Muldis::DB - 
     20Muldis::Rosetta - 
    2121Full-featured truly relational DBMS in Perl 
    2222 
    2323=head1 VERSION 
    2424 
    25 This document is Muldis::DB version 0.6.2. 
     25This document is Muldis::Rosetta version 0.6.2. 
    2626 
    2727=head1 DESCRIPTION 
    2828 
    29 The B<Muldis DB> DBMS framework is a powerful but elegant system, which 
    30 makes it easy to create and use relational databases in a very reliable, 
    31 portable, and efficient way.  This "DB" file provides a 10,000 mile view of 
    32 the Muldis DB framework as a whole, and the detail documentation for each 
    33 component is included with that component.  The distribution containing 
    34 this "DB" file is the I<Muldis DB core> distribution. 
    35  
    36 Loosely speaking, the Muldis DB framework at large is like the Perl DBI 
    37 framework at large, so if you know how to use the Perl DBI to work with 
     29The B<Muldis Rosetta> DBMS framework is a powerful but elegant system, 
     30which makes it easy to create and use relational databases in a very 
     31reliable, portable, and efficient way.  This "Rosetta" file provides a 
     3210,000 mile view of the Muldis Rosetta framework as a whole, and the detail 
     33documentation for each component is included with that component.  The 
     34distribution containing this "Rosetta" file is the I<Muldis Rosetta core> 
     35distribution. 
     36 
     37Loosely speaking, the Muldis Rosetta framework at large is like the Perl 
     38DBI framework at large, so if you know how to use the Perl DBI to work with 
    3839databases, it should be easy enough to apply that knowledge to using Muldis 
    39 DB to work with databases.  Like the Perl DBI, Muldis DB has separately 
    40 distributable core, implementation, and extension distributions.  Like an 
    41 implementation ("driver") of the Perl DBI, an implementation ("engine") of 
    42 Muldis DB works according to the command design pattern; its API is very 
    43 minimalistic and mainly serves to process arbitrary "commands" through a 
    44 single routine or three.  Unlike the Perl DBI, which takes commands in some 
    45 dialect of SQL, which changes based on the implementation in use, Muldis DB 
    46 takes commands in the B<Muldis D> language, which has just one dialect 
    47 shared by all implementations.  See the separate all-documentation 
    48 distribution L<Muldis::D> for the formal definition of the Muldis D 
    49 language which Muldis DB is based on. 
    50  
    51 The minimal core of the Muldis DB framework, the one component that 
    52 probably every program would use, is the L<Muldis::DB::Interface> file.  It 
    53 defines a small set of roles/classes that comprise a common API (that 
    54 processes I<Perl Hosted Data Muldis D> commands) for Muldis DB 
    55 implementations to do and which applications invoke, called the I<Muldis DB 
    56 Native Interface> (or I<MDBNI>).  For the most part, C<Interface> just 
    57 defines shims and it can only be used when they are subclassed by an 
     40Rosetta to work with databases.  Like the Perl DBI, Muldis Rosetta has 
     41separately distributable core, implementation, and extension distributions. 
     42 Like an implementation ("driver") of the Perl DBI, an implementation 
     43("engine") of Muldis Rosetta works according to the command design pattern; 
     44its API is very minimalistic and mainly serves to process arbitrary 
     45"commands" through a single routine or three.  Unlike the Perl DBI, which 
     46takes commands in some dialect of SQL, which changes based on the 
     47implementation in use, Muldis Rosetta takes commands in the B<Muldis D> 
     48language, which has just one dialect shared by all implementations.  See 
     49the separate all-documentation distribution L<Muldis::D> for the formal 
     50definition of the Muldis D language which Muldis Rosetta is based on. 
     51 
     52The minimal core of the Muldis Rosetta framework, the one component that 
     53probably every program would use, is the L<Muldis::Rosetta::Interface> 
     54file.  It defines a small set of roles/classes that comprise a common API 
     55(that processes I<Perl Hosted Data Muldis D> commands) for Muldis Rosetta 
     56implementations to do and which applications invoke, called the I<Muldis 
     57Rosetta Native Interface> (or I<MRNI>).  For the most part, C<Interface> 
     58just defines shims and it can only be used when they are subclassed by an 
    5859implementation.  In the Perl DBI framework analogy, C<Interface> 
    5960corresponds to the L<DBI> module itself.  An implementation is called a 
    60 I<Muldis DB Engine> or I<Engine>. 
    61  
    62 Thanks largely to the use of Muldis D as its command language, MDBNI is 
     61I<Muldis Rosetta Engine> or I<Engine>. 
     62 
     63Thanks largely to the use of Muldis D as its command language, MRNI is 
    6364rigorously defined, such that there should be no ambiguity when trying to 
    6465invoke or implement it, and so an application written to it should behave 
    6566identically no matter which conforming Engine is in use. 
    6667 
    67 The maximal core of the Muldis DB framework, everything else of substance 
    68 in the same distribution as the minimal core (and this "DB" file), 
    69 comprises 2 additional components.  The first is 
    70 L<Muldis::DB::Engine::Example>, a self-contained and pure-Perl reference 
    71 implementation of Muldis DB.  The second is L<Muldis::DB::Validator>, a 
    72 common comprehensive test suite for Muldis DB implementations.  Together, 
    73 these components make it possible for the Muldis DB core distribution to be 
    74 completely testable on its own.  It is therefore also feasible for an 
    75 application to use the Muldis DB core in isolation from further framework 
    76 components, though doing so isn't recommended for production use since 
    77 C<Example> is kept simple on purpose and doesn't scale well. 
    78  
    79 Muldis DB, by way of using the Muldis D language, incorporates a complete 
    80 and uncompromising implementation of "I<The Third Manifesto>" (I<TTM>), a 
    81 formal proposal by Christopher J. Date and Hugh Darwen for a solid 
    82 foundation for data and database management systems (DBMSs); like Edgar F. 
    83 Codd's original papers, I<TTM> can be seen as an abstract blueprint for the 
    84 design of a DBMS and the language interface to such a DBMS.  Muldis D is a 
    85 high-level programming language which is computationally complete (and 
    86 industrial strength) and has fully integrated database functionality; it 
    87 satisfies I<TTM>'s definition of a "B<D>" language.  The main web site for 
    88 I<TTM> is L<http://www.thethirdmanifesto.com/>, and its authors have also 
    89 written several books and papers and taught classes on the subject over the 
    90 last 35+ years, along with Codd himself (some are listed in the separately 
    91 distributed L<Muldis::D::SeeAlso> documentation file).  Note that 
    92 the Muldis DB documentation will be focusing mainly on how Muldis DB itself 
    93 works, and will not spend much time in providing rationale; you can read 
    94 I<TTM> itself and various other external documentation for much of that. 
     68The maximal core of the Muldis Rosetta framework, everything else of 
     69substance in the same distribution as the minimal core (and this "Rosetta" 
     70file), comprises 2 additional components.  The first is 
     71L<Muldis::Rosetta::Engine::Example>, a self-contained and pure-Perl 
     72reference implementation of Muldis Rosetta.  The second is 
     73L<Muldis::Rosetta::Validator>, a common comprehensive test suite for Muldis 
     74Rosetta implementations.  Together, these components make it possible for 
     75the Muldis Rosetta core distribution to be completely testable on its own. 
     76It is therefore also feasible for an application to use the Muldis Rosetta 
     77core in isolation from further framework components, though doing so isn't 
     78recommended for production use since C<Example> is kept simple on purpose 
     79and doesn't scale well. 
     80 
     81Muldis Rosetta, by way of using the Muldis D language, incorporates a 
     82complete and uncompromising implementation of "I<The Third Manifesto>" 
     83(I<TTM>), a formal proposal by Christopher J. Date and Hugh Darwen for a 
     84solid foundation for data and database management systems (DBMSs); like 
     85Edgar F. Codd's original papers, I<TTM> can be seen as an abstract 
     86blueprint for the design of a DBMS and the language interface to such a 
     87DBMS.  Muldis D is a high-level programming language which is 
     88computationally complete (and industrial strength) and has fully integrated 
     89database functionality; it satisfies I<TTM>'s definition of a "B<D>" 
     90language.  The main web site for I<TTM> is 
     91L<http://www.thethirdmanifesto.com/>, and its authors have also written 
     92several books and papers and taught classes on the subject over the last 
     9335+ years, along with Codd himself (some are listed in the separately 
     94distributed L<Muldis::D::SeeAlso> documentation file).  Note that the 
     95Muldis Rosetta documentation will be focusing mainly on how Muldis Rosetta 
     96itself works, and will not spend much time in providing rationale; you can 
     97read I<TTM> itself and various other external documentation for much of 
     98that. 
    9599 
    96100I<This documentation is pending.> 
    … …  
    101105either named modules or anonymous routines) and write the rest of the 
    102106application in their other language(s) of choice.  Assuming the main 
    103 application is written in Perl, it is the L<Muldis::DB::Interface> file 
    104 which provides the glue between your Perl code and your Muldis D code; 
    105 "Muldis::DB::Interface" implements a virtual machine that is embedded in 
    106 your Perl application and in which the Muldis D code runs (it is analogous 
    107 to the Perl interpreter itself, which provides a virtual machine in which 
    108 Perl code runs). 
    109  
    110 A Muldis::DB::Interface::Machine object represents a single active Muldis 
    111 DB virtual machine; it has a spartan DBI-inspired set of methods which you 
    112 use to compile/prepare and/or invoke/execute Muldis D statements and 
    113 routines within the virtual machine, input data to it, and output data from 
    114 it. 
     107application is written in Perl, it is the L<Muldis::Rosetta::Interface> 
     108file which provides the glue between your Perl code and your Muldis D code; 
     109"Muldis::Rosetta::Interface" implements a virtual machine that is embedded 
     110in your Perl application and in which the Muldis D code runs (it is 
     111analogous to the Perl interpreter itself, which provides a virtual machine 
     112in which Perl code runs). 
     113 
     114A Muldis::Rosetta::Interface::Machine object represents a single active 
     115Muldis Rosetta virtual machine; it has a spartan DBI-inspired set of 
     116methods which you use to compile/prepare and/or invoke/execute Muldis D 
     117statements and routines within the virtual machine, input data to it, and 
     118output data from it. 
    115119 
    116120You can create more than one Machine object at a time, and they are 
    117121essentially all isolated from each other, even if more than one uses the 
    118122same Engine class to implement it; that is, multiple Machine objects will 
    119 not have references to each other at a level visible in the Muldis DB 
     123not have references to each other at a level visible in the Muldis Rosetta 
    120124Native Interface, if at all.  To account for situations where multiple 
    121125Machine objects want to use the same external resources, such as a 
    122126repository file on disk, it is expected that the Engines will employ 
    123127appropriate measures such as system-managed locks so that resource 
    124 corruption or application failure is prevented.  I<Also, Muldis DB should 
    125 be thread safe and/or savvy in the future, but for now it officially is not 
    126 and you should not share Muldis DB objects between multiple threads, nor 
    127 have objects in separate threads try to access the same external 
    128 resources.> 
    129  
    130 Muldis DB does not use any dialect of SQL in its native API (unlike many 
    131 other DBMS products) because SQL is more ambiguous and error-prone to use, 
    132 and it is less expressive.  While Muldis D is very different from SQL, it 
    133 is fully capable of modeling anything in the real world accurately, and it 
    134 can support a complete SQL emulation layer on top of it, so that your 
    135 legacy applications can be migrated to use the Muldis DB DBMS with little 
    136 trouble.  Likewise, emulation layers for any other programming language can 
    137 be supported, such as B<Tutorial D> or XQuery or FoxPro or dBase. 
    138  
    139 One distinctive feature of a Muldis DB DBMS (compared to a typical other 
    140 vendor's DBMS) is that data definition statements are structured 
     128corruption or application failure is prevented.  I<Also, Muldis Rosetta 
     129should be thread safe and/or savvy in the future, but for now it officially 
     130is not and you should not share Muldis Rosetta objects between multiple 
     131threads, nor have objects in separate threads try to access the same 
     132external resources.> 
     133 
     134Muldis Rosetta does not use any dialect of SQL in its native API (unlike 
     135many other DBMS products) because SQL is more ambiguous and error-prone to 
     136use, and it is less expressive.  While Muldis D is very different from SQL, 
     137it is fully capable of modeling anything in the real world accurately, and 
     138it can support a complete SQL emulation layer on top of it, so that your 
     139legacy applications can be migrated to use the Muldis Rosetta DBMS with 
     140little trouble.  Likewise, emulation layers for any other programming 
     141language can be supported, such as B<Tutorial D> or XQuery or FoxPro or 
     142dBase. 
     143 
     144One distinctive feature of a Muldis Rosetta DBMS (compared to a typical 
     145other vendor's DBMS) is that data definition statements are structured 
    141146fundamentally as standard data manipulation statements but that the target 
    142147relation variables are system catalog relation variables rather than 
    … …  
    145150read-only, not only by using special 'create' or 'alter' statements. 
    146151 
    147 Each Muldis DB Engine has the complete freedom to implement the Muldis DB 
    148 DBMS and Muldis D however it likes; all Muldis DB cares about is that the 
    149 user interface and behaviour conform to its preconceptions. 
     152Each Muldis Rosetta Engine has the complete freedom to implement the Muldis 
     153Rosetta DBMS and Muldis D however it likes; all Muldis Rosetta cares about 
     154is that the user interface and behaviour conform to its preconceptions. 
    150155 
    151156For production use, there should be a wide variety of third party Engine 
    … …  
    153158the new (under development) enterprise-strength and Perl implemented 
    154159database server named L<Genezzo> (see also L<http://www.genezzo.com/>) will 
    155 evolve to implement the Muldis DB DBMS natively, and be I<the> back-end 
    156 which is recommended above all others for production use. 
     160evolve to implement the Muldis Rosetta DBMS natively, and be I<the> 
     161back-end which is recommended above all others for production use. 
    157162 
    158163Most of the other (near term) third party Engines will likely just map 
    159 Muldis DB's rigorously defined API onto a pre-existing quasi-relational 
    160 database manager (such as SQLite, PostgreSQL, MySQL, Firebird, Teradata, 
    161 Oracle, Sybase, SQL Server, Informix, DB2, OpenBase, FrontBase, etc). Given 
    162 this fact, Muldis DB's most prominent feature is that it provides a common 
    163 API for access to those databases, each of which takes a different SQL or 
    164 quasi-SQL dialect.  An application written to it should easily port to 
    165 alternative relational database engines with minimal effort. 
     164Muldis Rosetta's rigorously defined API onto a pre-existing 
     165quasi-relational database manager (such as SQLite, PostgreSQL, MySQL, 
     166Firebird, Teradata, Oracle, Sybase, SQL Server, Informix, DB2, OpenBase, 
     167FrontBase, etc). Given this fact, Muldis Rosetta's most prominent feature 
     168is that it provides a common API for access to those databases, each of 
     169which takes a different SQL or quasi-SQL dialect.  An application written 
     170to it should easily port to alternative relational database engines with 
     171minimal effort. 
    166172 
    167173This might seem strange to somebody who has not tried to port between 
    … …  
    170176is I<Database Driver Independence>, and not I<Database Language 
    171177Independence>.  To further demonstrate the difference, it is useful to 
    172 compare the DBI and Muldis DB.  I<Such documentation is currently absent.> 
    173  
    174 In the context of a Muldis DB implementation over the Perl DBI, if one were 
    175 to categorize Muldis DB among other Perl modules, it could reasonably be 
    176 called a database abstraction layer; but it should I<not> be called a Perl 
    177 object persistence layer, as that is a different paradigm. 
     178compare the DBI and Muldis Rosetta.  I<Such documentation is currently 
     179absent.> 
     180 
     181In the context of a Muldis Rosetta implementation over the Perl DBI, if one 
     182were to categorize Muldis Rosetta among other Perl modules, it could 
     183reasonably be called a database abstraction layer; but it should I<not> be 
     184called a Perl object persistence layer, as that is a different paradigm. 
    178185 
    179186=head1 FEATURE SUPPORT VALIDATION 
    180187 
    181 The Muldis DB Native Interface declares accessors for a large number of 
    182 actual or possible database features, any of which your application can 
    183 invoke, and all of which each Muldis DB Engine would ideally implement or 
    184 interface to. 
     188The Muldis Rosetta Native Interface declares accessors for a large number 
     189of actual or possible database features, any of which your application can 
     190invoke, and all of which each Muldis Rosetta Engine would ideally implement 
     191or interface to. 
    185192 
    186193In reality, however, all Engines or underlying databases probably don't 
    … …  
    190197corruption over time. 
    191198 
    192 As an official quality assurance (QA) measure, Muldis DB provides a means 
    193 for each Engine to programmatically declare which features it does and does 
    194 not support, so that code using that Engine will know so in advance of 
    195 trying to use said features.  Feature support declarations are typically 
    196 coarse grained and lump closely similar things together, for simplicity; 
    197 they will be just as fine grained as necessary and no finer (this can be 
    198 changed over time).  See the C<features()> method, which is how you read 
    199 the declarations. 
     199As an official quality assurance (QA) measure, Muldis Rosetta provides a 
     200means for each Engine to programmatically declare which features it does 
     201and does not support, so that code using that Engine will know so in 
     202advance of trying to use said features.  Feature support declarations are 
     203typically coarse grained and lump closely similar things together, for 
     204simplicity; they will be just as fine grained as necessary and no finer 
     205(this can be changed over time).  See the C<features()> method, which is 
     206how you read the declarations. 
    200207 
    201208One benefit of this QA feature is that, after you have written your 
    … …  
    204211alternatives also support the features you are using.  Note that, generally 
    205212speaking, you would have to be using very proprietary features to begin 
    206 with in order for the majority of Muldis DB Engines/databases to not 
     213with in order for the majority of Muldis Rosetta Engines/databases to not 
    207214support the application outright. 
    208215 
    209216Another benefit of this QA feature is that there can be made a common 
    210217comprehensive test suite to run against all Engines in order to tell that 
    211 they are implementing the Muldis DB interface properly or not; said test 
    212 suite will be smart enough to only test each Engine's compliance for those 
    213 features that the Engine claims to support, and not fail it for non-working 
    214 features that it explicitly says it doesn't support.  This common test 
    215 suite will save each Engine maker from having to write their own module 
    216 tests.  It would be used similarly to how Sun has an official validation 
    217 suite for Java Virtual Machines to make sure they implement the official 
    218 Java specification.  Please see the L<Muldis::DB::Validator> module(s), 
    219 which implements this test suite. 
     218they are implementing the Muldis Rosetta interface properly or not; said 
     219test suite will be smart enough to only test each Engine's compliance for 
     220those features that the Engine claims to support, and not fail it for 
     221non-working features that it explicitly says it doesn't support.  This 
     222common test suite will save each Engine maker from having to write their 
     223own module tests.  It would be used similarly to how Sun has an official 
     224validation suite for Java Virtual Machines to make sure they implement the 
     225official Java specification.  Please see the L<Muldis::Rosetta::Validator> 
     226module(s), which implements this test suite. 
    220227 
    221228=head1 SEE ALSO 
    222229 
    223 The separate all-documentation distribution L<Muldis::D> is the 
    224 formal definition of the Muldis D language which Muldis DB is based on. 
    225  
    226 The Perl module L<Muldis::DB::Validator> is bundled with Muldis DB and can 
    227 be used to test Muldis DB Engines. 
    228  
    229 The Perl module L<Muldis::DB::Engine::Example> is bundled with Muldis DB 
    230 and implements a self-contained reference implementation of a Muldis DB 
    231 Engine. 
    232  
    233 Go to the L<Muldis::DB::SeeAlso> file for the majority of external 
     230The separate all-documentation distribution L<Muldis::D> is the formal 
     231definition of the Muldis D language which Muldis Rosetta is based on. 
     232 
     233The Perl module L<Muldis::Rosetta::Validator> is bundled with Muldis 
     234Rosetta and can be used to test Muldis Rosetta Engines. 
     235 
     236The Perl module L<Muldis::Rosetta::Engine::Example> is bundled with Muldis 
     237Rosetta and implements a self-contained reference implementation of a 
     238Muldis Rosetta Engine. 
     239 
     240Go to the L<Muldis::Rosetta::SeeAlso> file for the majority of external 
    234241references. 
    235242 
    … …  
    240247=head1 LICENSE AND COPYRIGHT 
    241248 
    242 This file is part of the Muldis DB framework. 
    243  
    244 Muldis DB is Copyright © 2002-2008, Darren Duncan.  All rights reserved. 
    245 <