Changeset 17866 for ext

Show
Ignore:
Timestamp:
09/16/07 08:09:11 (16 months ago)
Author:
Darren_Duncan
Message:

ext/Muldis-DB/ : half rewrote desc of DB.pm, added small desc to Interface.pm, Example.pm

Location:
ext/Muldis-DB
Files:
5 modified

Legend:

Unmodified
Added
Removed

  • ext/Muldis-DB/Changes

    r17855 r17866  
    22--------------------------------------------------------------------------- 
    33 
    4 2007-09-14   Darren Duncan <perl@DarrenDuncan.net> 
    5  
    6     * Muldis DB version 0.3.2 for Perl 5 is released on CPAN as 
    7     Muldis-DB-0.3.2.tar.gz.  Muldis DB version 0.3.2 for Perl 6 is not 
     42007-09-xx   Darren Duncan <perl@DarrenDuncan.net> 
     5 
     6    * Muldis DB version 0.4.0 for Perl 5 is released on CPAN as 
     7    Muldis-DB-0.4.0.tar.gz.  Muldis DB version 0.4.0 for Perl 6 is not 
    88    released at this time, if ever, since it is currently released only as 
    99    part of the Perl6-Pugs project (in its ext/Muldis-DB/ subdirectory), 
    … …  
    1111    Changes entry refers only to the Perl 5 version. 
    1212 
     13    * New file versions are: DB.pm and Interface.pm and Validator.pm and 
     14    Example.pm 0.4.0.  The other pre-existing versioned files are 
     15    unchanged. 
     16 
     17    * (DB.pm, Interface.pm, Example.pm)  Updates to various 
     18    main/introductory documentation.  Half rewrote/prepended the 
     19    DESCRIPTION of DB.pm.  Added a small initial DESCRIPTION to each of 
     20    Interface.pm, Example.pm.  Further minor edits to other sections. 
     21 
     222007-09-14   Darren Duncan <perl@DarrenDuncan.net> 
     23 
     24    * Muldis DB version 0.3.2 for Perl 5 is released on CPAN as 
     25    Muldis-DB-0.3.2.tar.gz.  Muldis DB version 0.3.2 for Perl 6 is not 
     26    released at all.  The rest of this Changes entry refers only to the 
     27    Perl 5 version. 
     28 
    1329    * Removed the file Copying.pod; it isn't particularly useful anymore. 
    1430 
    15     * New file versions are: DB.pm 0.3.2. 
     31    * New file versions are: DB.pm 0.3.2.  The other pre-existing versioned 
     32    files are unchanged. 
    1633 
    1734    * (DB.pm)  The whole Muldis DB core, that is, all code in this 
    … …  
    26432007-08-18   Darren Duncan <perl@DarrenDuncan.net> 
    2744 
     45    Record update in the PAUSE modules database: 
     46 
     47           modid: [Muldis::DB] 
     48           statd: [c] 
     49           stats: [m] 
     50           statl: [p] 
     51           stati: [O] 
     52           statp: [l] was [g] 
     53     description: [Full-featured truly relational DBMS in Perl] 
     54          userid: [DUNCAND] 
     55       chapterid: [7] 
     56        mlstatus: [list] 
     57 
     582007-08-18   Darren Duncan <perl@DarrenDuncan.net> 
     59 
    2860    * Muldis DB version 0.3.1 for Perl 5 is released on CPAN as 
    2961    Muldis-DB-0.3.1.tar.gz.  Muldis DB version 0.3.1 for Perl 6 is not 
    … …  
    3870    version number declared in the Makefile.PL. 
    3971 
    40     * New file versions are: DB.pm and Copying.pod 0.3.1. 
     72    * New file versions are: DB.pm and Copying.pod 0.3.1.  The other 
     73    pre-existing versioned files are unchanged. 
    4174 
    4275    * (DB.pm, Copying.pod)  The license of Muldis DB has been simplified 

  • ext/Muldis-DB/README

    r17781 r17866  
    1010relational DBMS in Perl) and its support structure. 
    1111 
    12 Muldis::DB is the successor of the now-defunct Rosetta DBMS framework, 
     12Muldis DB is the successor of the now-defunct Rosetta DBMS framework, 
    1313which it is heavily based on and has learned from, though for all practical 
    14 purposes, Muldis::DB is a complete rewrite with significant changes.  (Note 
    15 that Muldis::DB was temporarily named QDRDBMS during its pre-release 
     14purposes, Muldis DB is a complete rewrite with significant changes.  (Note 
     15that Muldis DB was temporarily named QDRDBMS during its pre-release 
    1616development phase.)  Given the magnitude of the differences, the actual 
    17 change history of Rosetta itself is not relevant, and so Muldis::DB does 
     17change history of Rosetta itself is not relevant, and so Muldis DB does 
    1818not continue its version numbering or maintain the older change log.  The 
    19 first Muldis::DB release on CPAN was version 0.0.0, and that was released 
    20 2007.06.20.  But Muldis::DB does still declare copyright of 2002-present, 
     19first Muldis DB release on CPAN was version 0.0.0, and that was released 
     202007.06.20.  But Muldis DB does still declare copyright of 2002-present, 
    2121incorporating the Rosetta development/release time-period. 
    2222 
    23 Muldis::DB has 2 co-developed versions, which are written in native Perl 5 
     23Muldis DB has 2 co-developed versions, which are written in native Perl 5 
    2424and Perl 6 respectively, and which are distributed separately from each 
    2525other.  But while the 2 versions would be similar, they are explicitly not 
    … …  
    3939DOCUMENTATION READING ORDER 
    4040 
    41 If you want to read all the Muldis::DB documentation that exists now in 
     41If you want to read all the Muldis DB documentation that exists now in 
    4242this distribution, I recommend doing so in this order: 
    4343 
    … …  
    6666 
    6767For those of you that are interested in the bleeding edge of development, I 
    68 have all parts of the Muldis::DB project in one or more public 
    69 repositories. The Perl 5 Muldis::DB project is in a Git repository whose 
     68have all parts of the Muldis DB project in one or more public 
     69repositories. The Perl 5 Muldis DB project is in a Git repository whose 
    7070Git read-access url is "git://utsl.gen.nz/Muldis-DB" and whose Gitweb 
    7171information url is at "http://utsl.gen.nz/gitweb/?p=Muldis-DB".  The Perl 6 
    72 Muldis::DB project is in a Subversion repository at 
     72Muldis DB project is in a Subversion repository at 
    7373"http://svn.pugscode.org/pugs/ext/Muldis-DB/".  The last version of Rosetta 
    7474which was the closest to being functional, created between late 2002 and 
    … …  
    9999Currently, the best place to get basic support is the appropriate user 
    100100forums (see "http://mm.DarrenDuncan.net/mailman/listinfo"), which exist so 
    101 that Muldis::DB users can help each other, or that help coming from 
    102 Muldis::DB developers can be said once to many people, rather than to each 
     101that Muldis DB users can help each other, or that help coming from 
     102Muldis DB developers can be said once to many people, rather than to each 
    103103individually. 
    104104 
    105105Alternately, you can purchase more advanced commercial support for 
    106 Muldis::DB from the author; contact "perl@DarrenDuncan.net" for details. 
     106Muldis DB from the author; contact "perl@DarrenDuncan.net" for details. 
    107107 
    108108FIN 

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

    r17855 r17866  
    2525This document is Muldis::DB version 0.3.2. 
    2626 
    27 =head1 PREFACE 
     27=head1 DESCRIPTION 
     28 
     29The B<Muldis DB> DBMS framework is a powerful but elegant system, which 
     30makes it easy to create and use relational databases in a very reliable, 
     31portable, and efficient way.  This "DB" file provides a 10,000 mile view of 
     32the Muldis DB framework as a whole, and the detail documentation for each 
     33component is included with that component.  The distribution containing 
     34this "DB" file is the I<Muldis DB core> distribution. 
     35 
     36Loosely speaking, the Muldis DB framework at large is like the Perl DBI 
     37framework at large, so if you know how to use the Perl DBI to work with 
     38databases, it should be easy enough to apply that knowledge to using Muldis 
     39DB to work with databases.  Like the Perl DBI, Muldis DB has separately 
     40distributable core, implementation, and extension distributions.  Like an 
     41implementation ("driver") of the Perl DBI, an implementation ("engine") of 
     42Muldis DB works according to the command design pattern; its API is very 
     43minimalistic and mainly serves to process arbitrary "commands" through a 
     44single routine or three.  Unlike the Perl DBI, which takes commands in some 
     45dialect of SQL, which changes based on the implementation in use, Muldis DB 
     46takes commands in the B<Muldis D> language, which has just one dialect 
     47shared by all implementations.  See the separate all-documentation 
     48distribution L<Language::MuldisD> for the formal definition of the Muldis D 
     49language which Muldis DB is based on. 
     50 
     51The minimal core of the Muldis DB framework, the one component that 
     52probably every program would use, is the L<Muldis::DB::Interface> file.  It 
     53defines a small set of roles/classes that comprise a common API (that 
     54processes I<Perl Hosted Abstract Muldis D> commands) for Muldis DB 
     55implementations to do and which applications invoke, called the I<Muldis DB 
     56Native Interface> (or I<MDBNI>).  For the most part, C<Interface> just 
     57defines shims and it can only be used when they are subclassed by an 
     58implementation.  In the Perl DBI framework analogy, C<Interface> 
     59corresponds to the L<DBI> module itself.  An implementation is called a 
     60I<Muldis DB Engine> or I<Engine>. 
     61 
     62Thanks largely to the use of Muldis D as its command language, MDBNI is 
     63rigorously defined, such that there should be no ambiguity when trying to 
     64invoke or implement it, and so an application written to it should behave 
     65identically no matter which conforming Engine is in use. 
     66 
     67The maximal core of the Muldis DB framework, everything else of substance 
     68in the same distribution as the minimal core (and this "DB" file), 
     69comprises 2 additional components.  The first is 
     70L<Muldis::DB::Engine::Example>, a self-contained and pure-Perl reference 
     71implementation of Muldis DB.  The second is L<Muldis::DB::Validator>, a 
     72common comprehensive test suite for Muldis DB implementations.  Together, 
     73these components make it possible for the Muldis DB core distribution to be 
     74completely testable on its own.  It is therefore also feasible for an 
     75application to use Muldis DB in isolation from further framework 
     76components, though doing so isn't recommended for production use since 
     77C<Example> is kept simple on purpose and doesn't scale well. 
     78 
     79Muldis DB, by way of using the Muldis D language, incorporates a complete 
     80and uncompromising implementation of "I<The Third Manifesto>" (I<TTM>), a 
     81formal proposal by Christopher J. Date and Hugh Darwen for a solid 
     82foundation for data and database management systems (DBMSs); like Edgar F. 
     83Codd's original papers, I<TTM> can be seen as an abstract blueprint for the 
     84design of a DBMS and the language interface to such a DBMS.  Muldis D is a 
     85high-level programming language which is computationally complete (and 
     86industrial strength) and has fully integrated database functionality; it 
     87satisfies I<TTM>'s definition of a "B<D>" language.  The main web site for 
     88I<TTM> is L<http://www.thethirdmanifesto.com/>, and its authors have also 
     89written several books and papers and taught classes on the subject over the 
     90last 35+ years, along with Codd himself (some are listed in the separately 
     91distributed L<Language::MuldisD::SeeAlso> documentation file).  Note that 
     92the Muldis DB documentation will be focusing mainly on how Muldis DB itself 
     93works, and will not spend much time in providing rationale; you can read 
     94I<TTM> itself and various other external documentation for much of that. 
    2895 
    2996I<This documentation is pending.> 
    30  
    31 =head1 DESCRIPTION 
    32  
    33 The "Muldis::DB" DBMS framework is a powerful but elegant system, which 
    34 makes it easy to create and use relational databases in a very reliable, 
    35 portable, and efficient way.  This "Muldis::DB" file is the core of the 
    36 Muldis::DB framework and defines a truly relational common programmatic 
    37 interface (API), called the Muldis::DB Native Interface, which applications 
    38 invoke and which multiple interchangeable "Engine" back-ends (usually 
    39 provided by third parties) implement.  This interface is rigorously 
    40 defined, such that there should be no ambiguity when trying to invoke or 
    41 implement it, and so an application written to it should behave identically 
    42 no matter which conforming "Engine" is in use. 
    43  
    44 Muldis::DB incorporates a complete and uncompromising implementation of 
    45 "I<The Third Manifesto>" (I<TTM>), a formal proposal by Christopher J. Date 
    46 and Hugh Darwen for a solid foundation for data and database management 
    47 systems (DBMSs); like Edgar F. Codd's original papers, I<TTM> can be seen 
    48 as an abstract blueprint for the design of a DBMS and the language 
    49 interface to such a DBMS.  The main web site for I<TTM> is 
    50 L<http://www.thethirdmanifesto.com/>, and its authors have also written 
    51 several books and papers and taught classes on the subject over the last 
    52 35+ years, along with Codd himself (some are listed in the separately 
    53 distributed L<Language::MuldisD::SeeAlso> documentation file).  Note that 
    54 the Muldis::DB documentation will be focusing mainly on how Muldis::DB 
    55 itself works, and will not spend much time in providing rationale; you can 
    56 read I<TTM> itself and various other external documentation for much of 
    57 that. 
    58  
    59 The Muldis::DB Native Interface is defined mainly in terms of a new 
    60 high-level programming language named "Muldis D", which is computationally 
    61 complete (and industrial strength) and has fully integrated database 
    62 functionality; this language, which satisfies I<TTM>'s definition of a 
    63 "B<D>" language, is described fully in the L<Language::MuldisD> 
    64 documentation file that is distributed separately. 
    6597 
    6698While it is possible that one could write a self-contained application in 
    … …  
    76108Perl code runs). 
    77109 
    78 The classes and methods of L<Muldis::DB::Interface>, together with those of 
    79 L<Muldis::DB::Literal>, define the balance of the Muldis::DB Native 
    80 Interface.  A Muldis::DB::Interface::DBMS object represents a single active 
    81 Muldis::DB virtual machine; it has a spartan DBI-inspired set of methods 
    82 which you use to compile/prepare and/or invoke/execute Muldis D statements 
    83 and routines within the virtual machine, input data to it, and output data 
    84 from it. 
     110A Muldis::DB::Interface::DBMS object represents a single active Muldis DB 
     111virtual machine; it has a spartan DBI-inspired set of methods which you use 
     112to compile/prepare and/or invoke/execute Muldis D statements and routines 
     113within the virtual machine, input data to it, and output data from it. 
    85114 
    86115You can create more than one DBMS object at a time, and they are 
    87116essentially all isolated from each other, even if more than one uses the 
    88117same Engine class to implement it; that is, multiple DBMS objects will not 
    89 have references to each other at a level visible in the Muldis::DB Native 
     118have references to each other at a level visible in the Muldis DB Native 
    90119Interface, if at all.  To account for situations where multiple DBMS 
    91120objects want to use the same external resources, such as a repository file 
    92121on disk, it is expected that the Engines will employ appropriate measures 
    93122such as system-managed locks so that resource corruption or application 
    94 failure is prevented.  I<Also, Muldis::DB should be thread safe and/or 
     123failure is prevented.  I<Also, Muldis DB should be thread safe and/or 
    95124savvy in the future, but for now it officially is not and you should not 
    96 share Muldis::DB objects between multiple threads, nor have objects in 
     125share Muldis DB objects between multiple threads, nor have objects in 
    97126separate threads try to access the same external resources.> 
    98127 
    99 Muldis::DB does not use any dialect of SQL in its native API (unlike many 
     128Muldis DB does not use any dialect of SQL in its native API (unlike many 
    100129other DBMS products) because SQL is more ambiguous and error-prone to use, 
    101130and it is less expressive.  While Muldis D is very different from SQL, it 
    102131is fully capable of modeling anything in the real world accurately, and it 
    103132can support a complete SQL emulation layer on top of it, so that your 
    104 legacy applications can be migrated to use the Muldis::DB DBMS with little 
     133legacy applications can be migrated to use the Muldis DB DBMS with little 
    105134trouble.  Likewise, emulation layers for any other programming language can 
    106135be supported, such as B<Tutorial D> or XQuery or FoxPro or dBase. 
    107136 
    108 One distinctive feature of a Muldis::DB DBMS (compared to a typical other 
     137One distinctive feature of a Muldis DB DBMS (compared to a typical other 
    109138vendor's DBMS) is that data definition statements are structured as 
    110139standard data manipulation statements but that the target relation 
    … …  
    114143not by using special 'create' or 'alter' statements. 
    115144 
    116 Each Muldis::DB Engine has the complete freedom to implement the Muldis::DB 
    117 DBMS and Muldis D however it likes; all Muldis::DB cares about is that the 
     145Each Muldis DB Engine has the complete freedom to implement the Muldis DB 
     146DBMS and Muldis D however it likes; all Muldis DB cares about is that the 
    118147user interface and behaviour conform to its preconceptions. 
    119  
    120 L<Muldis::DB::Engine::Example> is the self-contained and pure-Perl 
    121 reference implementation of an Engine and is included in the "Muldis::DB" 
    122 core distribution to allow the core to be completely testable on its own. 
    123 It is coded intentionally in a simple fashion so that it is easy to 
    124 maintain and and easy for developers to study.  As a result, while it 
    125 performs correctly and reliably, it also performs quite slowly; you should 
    126 only use Example for testing, development, and study; you should not use it 
    127 in production. 
    128148 
    129149For production use, there should be a wide variety of third party Engine 
    … …  
    131151the new (under development) enterprise-strength and Perl implemented 
    132152database server named L<Genezzo> (see also L<http://www.genezzo.com/>) will 
    133 evolve to implement the Muldis::DB DBMS natively, and be I<the> back-end 
     153evolve to implement the Muldis DB DBMS natively, and be I<the> back-end 
    134154which is recommended above all others for production use. 
    135155 
    136156Most of the other (near term) third party Engines will likely just map 
    137 Muldis::DB's rigorously defined API onto a pre-existing quasi-relational 
     157Muldis DB's rigorously defined API onto a pre-existing quasi-relational 
    138158database manager (such as SQLite, PostgreSQL, MySQL, Firebird, Teradata, 
    139159Oracle, Sybase, SQL Server, Informix, DB2, OpenBase, FrontBase, etc). Given 
    140 this fact, Muldis::DB's most prominent feature is that it provides a common 
     160this fact, Muldis DB's most prominent feature is that it provides a common 
    141161API for access to those databases, each of which takes a different SQL or 
    142162quasi-SQL dialect.  An application written to it should easily port to 
    … …  
    148168is I<Database Driver Independence>, and not I<Database Language 
    149169Independence>.  To further demonstrate the difference, it is useful to 
    150 compare the DBI and Muldis::DB.  I<Such documentation is currently absent.> 
     170compare the DBI and Muldis DB.  I<Such documentation is currently absent.> 
    151171 
    152172=head1 FEATURE SUPPORT VALIDATION 
    153173 
    154 The Muldis::DB Native Interface declares accessors for a large number of 
     174The Muldis DB Native Interface declares accessors for a large number of 
    155175actual or possible database features, any of which your application can 
    156 invoke, and all of which each Muldis::DB Engine would ideally implement or 
     176invoke, and all of which each Muldis DB Engine would ideally implement or 
    157177interface to. 
    158178 
    … …  
    163183corruption over time. 
    164184 
    165 As an official quality assurance (QA) measure, Muldis::DB provides a means 
     185As an official quality assurance (QA) measure, Muldis DB provides a means 
    166186for each Engine to programmatically declare which features it does and does 
    167187not support, so that code using that Engine will know so in advance of 
    … …  
    177197alternatives also support the features you are using.  Note that, generally 
    178198speaking, you would have to be using very proprietary features to begin 
    179 with in order for the majority of Muldis::DB Engines/databases to not 
     199with in order for the majority of Muldis DB Engines/databases to not 
    180200support the application outright. 
    181201 
    182202Another benefit of this QA feature is that there can be made a common 
    183203comprehensive test suite to run against all Engines in order to tell that 
    184 they are implementing the Muldis::DB interface properly or not; said test 
     204they are implementing the Muldis DB interface properly or not; said test 
    185205suite will be smart enough to only test each Engine's compliance for those 
    186206features that the Engine claims to support, and not fail it for non-working 
    … …  
    195215 
    196216The separate all-documentation distribution L<Language::MuldisD> is the 
    197 formal definition of the Muldis D language which Muldis::DB is based on. 
    198  
    199 The Perl module L<Muldis::DB::Validator> is bundled with Muldis::DB and can 
    200 be used to test Muldis::DB Engines. 
    201  
    202 The Perl module L<Muldis::DB::Engine::Example> is bundled with Muldis::DB 
    203 and implements a self-contained reference implementation of a Muldis::DB 
     217formal definition of the Muldis D language which Muldis DB is based on. 
     218 
     219The Perl module L<Muldis::DB::Validator> is bundled with Muldis DB and can 
     220be used to test Muldis DB Engines. 
     221 
     222The Perl module L<Muldis::DB::Engine::Example> is bundled with Muldis DB 
     223and implements a self-contained reference implementation of a Muldis DB 
    204224Engine. 
    205225 
    … …  
    251271 
    252272Several public email-based forums exist whose main topic is all 
    253 implementations of the Muldis D language, especially the L<Muldis::DB> 
    254 project, which they are named for.  All of these you can reach via 
    255 L<http://mm.DarrenDuncan.net/mailman/listinfo>; go there to manage your 
    256 subscriptions to, or view the archives of, the following: 
     273implementations of the L<Muldis D|Language::MuldisD> language, especially 
     274the L<Muldis DB|Muldis::DB> project, which they are named for.  All of 
     275these you can reach via L<http://mm.DarrenDuncan.net/mailman/listinfo>; go 
     276there to manage your subscriptions to, or view the archives of, the 
     277following: 
    257278 
    258279=over 
    … …  
    260281=item C<muldis-db-announce@mm.DarrenDuncan.net> 
    261282 
    262 This low-volume list is mainly for official announcements from the 
    263 Muldis::DB developers, though developers of Muldis::DB extensions can also 
    264 post their announcements here.  This is not a discussion list. 
     283This low-volume list is mainly for official announcements from the Muldis 
     284DB developers, though developers of Muldis DB extensions can also post 
     285their announcements here.  This is not a discussion list. 
    265286 
    266287=item C<muldis-db-users@mm.DarrenDuncan.net> 
    267288 
    268 This list is for general discussion among people who are using Muldis::DB, 
    269 which is not concerned with the implementation of Muldis::DB itself.  This 
    270 is the best place to ask for basic help in getting Muldis::DB installed on 
     289This list is for general discussion among people who are using Muldis DB, 
     290which is not concerned with the implementation of Muldis DB itself.  This 
     291is the best place to ask for basic help in getting Muldis DB installed on 
    271292your machine or to make it do what you want.  You could also submit feature 
    272293requests or report perceived bugs here, if you don't want to use CPAN's RT 
    … …  
    276297 
    277298This list is for discussion among people who are designing or implementing 
    278 the Muldis::DB core API (including Muldis D language design), or who are 
    279 implementing Muldis::DB Engines, or who are writing core documentation, 
     299the Muldis DB core API (including Muldis D language design), or who are 
     300implementing Muldis DB Engines, or who are writing core documentation, 
    280301tests, or examples.  It is not the place for non-implementers to get help 
    281302in using said. 
    … …  
    283304=back 
    284305 
    285 An official IRC channel for Muldis::DB is also intended, but not yet 
     306An official IRC channel for Muldis DB is also intended, but not yet 
    286307started. 
    287308 
    288309Alternately, you can purchase more advanced commercial support for various 
    289 Muldis D implementations, particularly Muldis::DB, from its author; contact 
     310Muldis D implementations, particularly Muldis DB, from its author; contact 
    290311C<perl@DarrenDuncan.net> for details. 
    291312 

  • ext/Muldis-DB/lib/Muldis/DB/Engine/Example.pm

    r17127 r17866  
    177177=head1 DESCRIPTION 
    178178 
     179B<Muldis::DB::Engine::Example>, aka the I<Muldis DB Example Engine>, aka 
     180I<Example>, is the self-contained and pure-Perl reference implementation of 
     181Muldis DB.  It is included in the Muldis DB core distribution to allow the 
     182core to be completely testable on its own. 
     183 
     184Example is coded intentionally in a simple fashion so that it is easy to 
     185maintain and and easy for developers to study.  As a result, while it 
     186performs correctly and reliably, it also performs quite slowly; you should 
     187only use Example for testing, development, and study; you should not use it 
     188in production.  (See the L<Muldis::DB::SeeAlso> file for a list of other 
     189Engines that are more suitable for production.) 
     190 
     191This C<Muldis::DB::Engine::Example> file is the main file of the Example 
     192Engine, and it is what applications quasi-directly invoke; it directly 
     193does/subclasses the roles/classes in L<Muldis::DB::Interface>.  The other 
     194C<Muldis::DB::Engine::Example::\w+> files are used internally by it, 
     195comprising the rest of the Example Engine, and are not intended to be used 
     196directly in user code. 
     197 
    179198I<This documentation is pending.> 
    180199 
    … …  
    198217It also requires these Perl 6 classes that are in the current distribution: 
    199218L<Muldis::DB::Interface-0.3.0|Muldis::DB::Interface>. 
     219 
     220It also requires these Perl 6 classes that are in the current distribution: 
     221L<Muldis::DB::Engine::Example::PhysType-0.3.0| 
     222Muldis::DB::Engine::Example::PhysType>, 
     223L<Muldis::DB::Engine::Example::Operators-0.3.0| 
     224Muldis::DB::Engine::Example::Operators>. 
    200225 
    201226=head1 INCOMPATIBILITIES 

  • ext/Muldis-DB/lib/Muldis/DB/Interface.pm

    r17127 r17866  
    430430=head1 DESCRIPTION 
    431431 
     432B<Muldis::DB::Interface>, aka I<Interface>, comprises the minimal core of 
     433the Muldis DB framework, the one component that probably every program 
     434would use.  Together with the Muldis D language (see L<Language::MuldisD>), 
     435it defines the common API for Muldis DB implementations to do and which 
     436applications invoke. 
     437 
    432438I<This documentation is pending.> 
    433439