Relational Algebra Engine https://github.com/agentm/project-m36
|Latest on Hackage:||0.6|
This package is not currently in any snapshots. If you're interested in using it, we recommend adding it to Stackage Nightly. Doing so will make builds more reliable, and allow stackage.org to host generated Haddocks.
Ξ Project:M36 Relational Algebra Engine
Software can always be made faster, but rarely can it be made more correct.
Project:M36 implements a relational algebra engine as inspired by the writings of Chris Date.
Unlike most database management systems (DBMS), Project:M36 is opinionated software which adheres strictly to the mathematics of the relational algebra. The purpose of this adherence is to prove that software which implements mathematically-sound design principles reaps benefits in the form of code clarity, consistency, performance, and future-proofing.
Project:M36 can be used as an in-process or remote DBMS.
Project:M36 is written entirely in the Haskell programming language.
You can experiment instantly with Project:M36 straight from your browser at try.project-m36.io!
Project:M36 supports multiple frontends which target different audiences.
- learn about the relational algebra via TutorialD
- store and manipulate databases
- use Project:M36 as a native Haskell database backend
- Developer’s Blog
- Mailing List/Discussion Group
- IRC Channel: chat.freenode.net #project-m36
- Diogo Biazus’ Project:M36 Video Tutorial
- Installation and Introduction to Project:M36
- Introduction to the Relational Algebra
- TutorialD via Jupyter Notebook Walkthrough
- TutorialD Tutorial
- 15 Minute Tutorial
- Developer’s Change Log
- Simple Client API
- Transaction Graph Operators
- ProjectM36.Client Library
- Data Frames for Sorting
- Adding New Data Types
- Database-Manipulating Functions
- Serving Remote ProjectM36 Databases
- Using Notifications
- Merge Transactions
- Atom (Value) Functions
- Trans-Graph Relational Expressions
- Isomorphic Schemas
- Basic Operator Benchmarks
Project:M36 is developed in Haskell and compiled with GHC 8.0.2 or later.
- The Third Manifesto: the philosophical basis for relational algebra engines
- Rel: a TutorialD implementation against a BerkeleyDB backend
- Andl: a new database language with SQLite and PostgreSQL backends
- Coddie: a python-based relational algebra interpreter
- Out of the Tarpit: a proposed software architecture which minimizes state and complexity. Project:M36 implements the requirements of this paper.
- Database Design & Relational Theory: Normal Forms and All That Jazz: mathematical foundations for the principles of the relational algebra
- Database Explorations: Essays on the Third Manifesto and Related Topics: additional essays and debates on practical approaches to relational algebra engine design
- fix atom type parsing to support more complex data types
- add data frames to support server-side sort ordering, limits, and offsets
- fix atom function type validation
- add support for GHC 8.4 (now we support GHC 8.0, 8.2, and 8.4)
- fix critical type bug which allowed unresolved types to be used
- add full support for GHC 8.2 with stack or cabal (delayed for a long time by dependency version boundaries)
- drop support for GHC 7.10
- add support for
with (relexpr as name,...)syntax for use as tutd macros
NonEmptyListlist data type
- add contributed feature to allow users to create arbitrary relations
- fix type validation bug allowing concrete type with type variables in relations
- improve usability of
Interval adata type
Integerto be parsed as negative in
- support precompiled (Haskell)
- make TutorialD scripts read from the filesystem unconditionally read as UTF-8
- improve support for display of multibyte characters in
tutdconsole, especially Chinese
- fix file descriptor leak in file sychronization
- improve reliability by allowing fast-forward commits when using
- added various new static optimizations
- alter websocket server API to allow for multiple representations (JSON, text, or HTML) to be selected and returned simultaneously
- add jupyter kernel for TutorialD interpreter
- fix warnings suggested by new hlint 2.0.10
- replaced overuse of
- allow notifications to return query results from before and after the commit which triggered the notification
- alert users in
tutdconsole before a transaction graph expression is evaluated which would throw out their changes
- drastically-improved CSV import/export now supports all possible types except
- fix serious file handle leaks when using on-disk persistence
- fix case where invalid number of arguments to
ConstructedAtomdid not result in an error
- add support for
- a new simple client API with a monadic transaction manager
- complete hlint compliance
- the generics-based Tupleable typeclass which makes it easy to marshal Haskell data types to-and-from the database
- timestamps attached to transactions to allow specific point-in-time travel
- autoMergeToHead, a variant of commit which attempts to merge and commit to the latest head transaction to reduce incidents of TransactionNotAHeadErrors
- interval data types
- transaction dirtiness detection which allows the client to determine if an update expression actually changed the database state
In preparation for the simpler monad client API, ProjectM36.Client now includes a server-side merge for new transactions called “automerge”. This feature should reduce head contention in cases where new transactions can be simply merged to the head without additional processing. The trade-off is reduced
TransactionIsNotAHeadErrors but an increased chance of merge errors. The feature operates similarly to a server-side git rebase.
critical bug in merging
Successfully merged transactions did not have their constraints validated. Fixed.
add file locking
This feature allows Project:M36 database directories to be shared amongst multiple Project:M36 processes. This is similar to how SQLite operates except that the remote server mode supports the feature as well. This could allow, for example, multi-master, file-based replication across Windows shares or NFS.
add functional dependency macro
Date demonstrates two ways to implement functional dependencies as constraints on page 21 in “Database Design and Relational Theory”. A similar macros is now implemented in the tutd interpreter.
funcdep sname_status (sname) -> (status) s
The TransGraphRelationalExpr allows queries against all past states of the database.
The following example executes a query against two different committed transactions using syntax similar to that of git for graph traversal:
:showtransgraphexpr s@master~ join sp@master