Below is a list of projects related to TTM that have come to our attention. See also Implementers' Reflections for further information from the authors of some of these projects.
Contents: Rel relational.js EE/IBL Andl Sira_Prise Muldis Rosetta RAQUEL Duro Alf D4 D♭ CsiDB MighTyD Web Relational Blocks Dee Erki Eessaar's Ph.D. TclRAL Ingres D Re Beyond The Four Fours
relational.js is
an experimental logic-programming package by Erik Olson based on the relational
model that implements the definitional algebra A.This package conforms to a subset of the RM Prescriptions and RM Proscriptions defined
in TTM for a relational language D. An approach is offered distinct from the proposals of
Darwen and Date in TTM in that a Horn-clause theorem-proving system is
provided for computing relations with definite cardinalities as results of
queries of relations with indefinite cardinalities.
EE (Executable English) is a user-friendly language implemented for shared use by non-programmers in the IBL (Internet Business Logic) web site since 2005.
EE provides 1st order predicate logic with recursion and negation. It provides for the definition of relations/tables and all the operations required of the Relational Model published by E.F. Codd in 1970. Data may be directly included in the tables, or alternatively IBL may access and update data through a networked SQL interface. EE is free of the logical problems of SQL.
EE/IBL provides for non-programmers to implement an application complete with data storage and access. The user sees a menu of questions written using the most appropriate vocabulary for the application within a highly flexible syntax unconstrained by reserved words. The user can type in a free English question, which the system will match to known sentences. Or, the user chooses which question to ask, specifying particular parameters if appropriate. IBL searches the rules and tables to determine whether 0, 1 or many answers can be found, showing the table of results to the user. The user can ask for an explanation of any answer (or failure to find one). IBL then shows a hypertexted English explanation leading to that conclusion. As the rules are all written by the application implementer in the non-programmer-friendly syntax, this explanation is expressed entirely in terms designed to be easy for the user to understand.
Note that though the language is known as Executable English, words of any other language supported by a generally available alphabet can be used. The only restriction on this is a very limited number of words such as “not” or “url” and then only in some specific syntactic constructs. These words therefore are not reserved in that they can be used elsewhere in ordinary EE sentences without restriction.
Constraints on data can be expressed using the full power of EE’s 1st order predicate logic. A constraint may be associated with addition of a row to a particular table or invoked as appropriate by the user. A constraint may include recursion, negation, and reference to the rows of any available tables. To avoid logical inconsistency (e.g. Russell’s Paradox) negation is excluded within a recursive loop. As presently implemented in IBL, there is no provision for these constraints to be reserved to a central authority, as opposed to being open to change by the implementer of the application. Providing for limiting authority to define or change DDL as in a typical DBMS, is work in progress.
The design and an earlier implementation of EE predated TTM, therefore it was not developed with TTM in mind. Consequently EE may not observe the RM Prescriptions to the letter. In particular, EE does not “name” things in the conventional sense, and this includes types and attributes. EE does however support defining both the standard types of TTM and user-defined types. It also avoids the relevant problems of SQL that TTM addresses.
See
the web site www.reengineeringllc.com/index.html
for further information and to use EE/IBL on the demo ID. The demo ID provides many
example apps, and
you can use it to write and run your own examples.
Questions may be directed to the author of
EE/IBL, Adrian Walker, via that web site or to Martin King through the TTM discussion group.
Andl (A New Database Language) does what SQL does, but
it is not SQL. Andl
has been developed
as a fully featured database programming language following
the principles set
out by Date and Darwen in The
Third Manifesto. It includes a
full implementation of the Relational Model published by E.F. Codd in
1970, an
advanced extensible type system, database updates and other SQL-like
capabilities in a novel and highly expressive syntax.
The
intended role of Andl
is to be the implementation language for the data
model of an application. It is already possible to code the business
model of
an application in SQL dialects such as SQL/PSM (SQL Standard and IBM
DB2),
PL/SQL (Oracle) or Transact-SQL (Microsoft) but SQL has its share of
problems
(see here)
and few
people make this choice. Andl
aims to provide a language free of these
problems that works on all these platforms.
The
intended role for Andl
is as follows. An application developer takes a
set of business requirements that comprise a data model, a set of
operations on
that model, and a set of requirements for users to interact with the
model. The
data model is implemented in the form of tables in a relational
database
management system, and the user interface and related business
requirements are
implemented using some chosen front end technology: web, desktop or
mobile as
needed. The operations on the data model are implemented in Andl, which
also provides the means by which the user interface queries and updates
the
data in the model.
The
effect is that the ‘object relational mismatch’ disappears, and there
is no
longer any need for an ‘object relational mapper’. No objects are
needed
between the data model and the user interface, just simple data values
as
individual items, rows or tables.
There is
still a role for a general purpose programming language like C# or
Java, acting
as glue to join various parts together and also in implementing various
parts
of the type system that Andl depends on. There is
still a role for a
front end technology based on languages such as HTML and JavaScript
since Andl
does not offer a user interface. But for the heart of the business
application,
for operations on the data and for implementing the rules, there is Andl.
See the web site http://www.andl.org for further information and downloads, why we need it, problems with SQL and a TTM paraphrase to read further, or contact the author David Bennett as david at the same domain.
The following characteristics distinguish SIRA_PRISE from most of the other TTM projects mentioned on this page :
• The engine is stand-alone and needs no other external software than a Java VM to run in.
• It deliberately does not try to create a full-blown D as its language. This makes SIRA_PRISE (and its DML language) behave more like a "traditional" data sublanguage than like a D.
The following features are considered the most important by the author (and are also what makes SIRA_PRISE noteworthy in his opinion):
• Efficient enforcement of data integrity constraints of arbitrary complexity.
• Support for multiple assignment, albeit not exactly and entirely the TTM kind.
• Support for Temporal data through support for interval types.
• Support for plug-in types and operators (User-Defined types and operators using a user-provided Java implementation).
• Clean separation between the logical design and the physical design of a database.
The following features are on the author's wish-list but not yet implemented :
• Support for Specialization by constraint
• Support for distributed databases
• Support for TTM-style UDTs (i.e. without requiring a user-provided java implementation)
As a DBMS needs a ‘driver application’ to supply it with statements to execute and to receive the consequences of their execution, a prototype GUI Frontend has also been published that is designed to help create statements in RAQUEL and receive error messages and query results.
The prototype is the start of an Open Source project to evolve the DBMS into a commercial product. The prototype software runs on Linux. The source code of both the DBMS and the GUI can be downloaded from SourceForge at http://sourceforge.net/projects/raqueldbsystem/files/ .
The DBMS prototype implements Project and Restrict operators, and a range of related Natural Join and Generalised Join operators; plus assignments for Retrieving query data, Inserting and Deleting relvalues, and creating Real (or Base) relvars; the scalar types implemented are the Truth, Number and Text types. As a prototype, the DBMS is still too limited to be of real practical use. Its biggest limitation is that the ability to create/remove relvars can only be done by manipulating the storage of the relevant Meta DB relvars. Implementing create/remove assignments is the next priority.
https://github.com/blambeau/alf
(source code)
http://rubydoc.info/github/blambeau/alf/master/frames
(documentation)
Alf is a pragmatic tool that, among other things, provides the relational algebra in a shell. It provides a (straightforward but useful) implementation of almost all Tutorial D relational algebra operators. Each of them comes as single shell command taking relation operands from SQL tables, CSV files or other Alf commands.
Alf also provides a functional domain specific language (DSL) for evaluating relational queries directly in Ruby, the programming language in which it is implemented.
Under the covers, Alf aims at bringing together the agile, pragmatic and test-driven oriented programming of the Ruby world and the sound and powerful approach to relational theory offered by TTM and related research. In that respect, Alf also aims at becoming an educational and research tool.
CsiDb
is a C++ library developed internally by an international corporation,
and used in a general bookkeeping and accounting application. The
application is complex and database-intensive, accommodating a wide
array of bookkeeping practices. CsiDb is an ongoing attempt to simplify
interaction between the application and the database by providing a
native C++ interface to a back-end DBMS. The interface allows users to
easily build relational query expressions which are eventually
translated into SQL. The interface is modelled closely on the semantics
of Tutorial D and the
other concepts in The Third Manifesto.
The library has been under sporadic development since 1999, by a single
developer. As of mid-2004, it provides a robust and fairly complete
query capability, but only rudimentary functionality for database
updates. It has been successfully used to simplify and speed up
significant portions of the application, replacing or supplementing an
in-house object/database mapping layer.
Supports scalar operators involving intervals and relational operators PACK, UNPACK, and most of the U_ operators. Intended for teaching purposes and for further extension by anybody who might be so inclined.
The project was highly acclaimed by the assessors at Warwick University. The team: Rachel Bowers, Adrian Hudnott, Sergey Petrov, Tom Pick, Issam Souilah. Hugh Darwen was their appointed "customer".
Unfortunately work on ths project was abandoned in 2011. Its original aims are given below for interest's sake only.
Ingres Project D is a project to add support for the Tutorial D language to Ingres Database server. Ingres Database server already has two data definition and manipulation languages, SQL and QUEL, where the latter originates from the tuple relational calculus. Project D will enable database development using a fully compliant D development environment consisting of Ingres Database server and a superset of Tutorial D, with supporting tools. It and will succeed where QUEL succumbed to SQL, and in doing so rejuvenate the original Ingres vision of a high performance relational DBMS and at the same time augment it to include the more recent work of Date and Darwen. It will deliver an industrial strength DBMS that will eventually implement everything in The Third Manifesto and Temporal Data and the Relational Model.
Ingres D is being constructed as a collaboration between Ingres Corporation, Adrian Hudnott, who is a PhD student at the University of Warwick in the UK, and Kai-Uwe Sattler's research group at Technische Universität Ilmenau in Germany. Original research is being carried out to support development of the following features for Project D.
• Enforcement of complex data integrity constraints with only a very low impact on performance for most constraints
• Materialized views/virtual relvars
• Semantic optimization of relational expressions
• Efficient multiple simultaneous assignment
• Temporal database optimization
• Specialization by Constraint
• Unrestricted updates to virtual relvars (where possible)
• Self-organizing physical storage structures ("autonomous DBMS")
re is implemented using PHP; thus, re can also be called as a
"PHP
API", or a "PHP Framework"/"PHP Library". But whatever fashionable name
re might be generalised to, it must be understood that re's basis is a
rigorous scientific theory. PHP was chosen as the implementing language
for a variety of reasons. First, PHP is popular enough. For this
reason, this project hopes that a useful and foundational theory can be
used (even if not to its full potential) and appreciated by a wider
audience. Another is that PHP has certain features which allow for a
more "straightforward approach" on some implementation-related
considerations.