HaskRel-0.1.0.1: HaskRel.cabal
name: HaskRel
version: 0.1.0.1
synopsis: HaskRel, Haskell as a DBMS with support for the relational
algebra
description:
HaskRel aims to define those elements of the relational theory of database
management that Haskell can accommodate, thus enabling Haskell (or more
precisely GHC) in its own right as a DBMS with first-class support for those
parts of the relational model. It does not qualify as a proper RDBMS since it
as-is only defines the relational algebra, relational variables and relational
assignment. It does not define the relational calculus, views, constraints and
transactions (beyond the fundamental requirement that the tuples of relations
are to be unique), certain operators like relation valued aggregate operators,
nor a few minor or even deprecated operators such as DIVIDE. The implemented
parts are decently complete even if there are major implementation
shortcomings that prevent this from being practically usable as an actual
DBMS.
.
I refer to it as "/first-class/" since the types of the relational model are
first-class types to Haskell, and the Haskell type system is able to induce
the type resulting of relational expressions (for instance that a natural join
of two relations results in a relation with a heading that is the setwise
union of the headings of the original relations).
.
= Examples
.
The examples in this documentation are based on "the old warhorse" that is the
suppliers-parts database (see [1] for more). This gives a body of relational
expressions with known results to base examples upon. See also
examples\/SuppliersPartsExamples.hs (not visible from this documentation) for
Haskell versions of a selection of the Tutorial D expressions given as
examples in chapters 6 and 7 of [1]. These can be run by starting
examples\/suppliersPartsDB.sh and then running @snrt2ndExamples@. While most
Tutorial D expressions translate fairly verbatim to Haskell there are a few
where one must be a bit more explicit. While most Tutorial D expressions
translate fairly verbatim to Haskell there are a few where Haskell is stricter
than Tutorial D and one must be a bit more explicit.
.
$ is always used after `p`\/`rPrint` or `pt`\/`rPrintTyped` in the examples to
keep them uniform (and so it kinda looks like a prompt), even when not
required. The short forms `p` and `pt` are used whenever there isn't a
conflict with other identifiers, whereas for the SuppliersPartsExample, which
has a relvar "@p@", `rPrint` is used instead of `p` for presentation of
relational objects without type information.
.
= Terminology
.
Since this builds on both Haskell and relational theory this documentation
uses terms as they have been established in material related to
either. Several terms of Haskell and HList have been redefined in terms of
relational theory in this library, mostly to illustrate how terms and concepts
have been mapped from the latter to the former. (I'm trying to keep this open
to change later if it turns out to be an unhelpful crutch.)
.
The following table gives a quick overview of either terms or concepts as
found in Haskell, the relational model (as presented in [1]), HaskRel and SQL,
and how they are mapped from the second to the first:
.
@
┌───────────────────────────┬────────────────────┬────────────┬────────────────────────────────────────────────┐
│ haskell │ relModel │ haskRel │ sql │
╞═══════════════════════════╪════════════════════╪════════════╪════════════════════════════════════════════════╡
│ <https://hackage.haskell.org/package/tagged/docs/Data-Tagged.html Data.Tagged.Tagged> │ attribute │ Attr │ field, column │
│ <https://hackage.haskell.org/package/HList/docs/Data-HList-Record.html Data.HList.Record.Record> │ tuple │ RTuple │ row │
│ ( <https://hackage.haskell.org/package/containers/docs/Data-Set.html Set> (<https://hackage.haskell.org/package/HList/docs/Data-HList-Record.html Record> a) ) │ relation │ Relation a │ table │
│ <https://hackage.haskell.org/package/filepath/docs/System-FilePath.html FilePath> (<https://hackage.haskell.org/package/containers/docs/Data-Set.html Set> (<https://hackage.haskell.org/package/HList/docs/Data-HList-Record.html Record> a)) │ relvar │ Relvar a │ table │
│ <https://hackage.haskell.org/package/HList/docs/Data-HList-FakePrelude.html#t:Label Data.HList.Record.Label> │ attribute name │ Label │ field name, column name │
│ <https://hackage.haskell.org/package/HList/docs/Data-HList-Record.html#t:Labels Data.HList.Record.Labels> │ attribute name set │ Labels │ list of field/column names │
│ function, operator │ operator │ function │ operator, function, procedure, routine, method │
└───────────────────────────┴────────────────────┴────────────┴────────────────────────────────────────────────┘
@
.
Found in "example\/Terminology.hs". Note that this is just an overview, study
of [1] or [2], Haskell itself, HList and HaskRel is required to see how terms
and concepts correlate.
.
The term \"RTuple\", or "r-tuple", is chosen to simultaneously distinguish the
concept from Haskell tuples while relating it to tuples of the relational
model. For the type of either "Record a" or "Set ( Record a )" in Haskell the
term "heading" is used in relational theory, and "row type" or "composite
type" in SQL. In relational theory the term "scalar" is used to refer to data
types that are neither tuples nor relations, which corresponds to everything
but "Record a" or "Set ( Record a )" in Haskell. Note also that HaskRel /does/
use the term "table", but then only in the sense of "presentation of a
relation value" (see above).
.
== The HaskRel library
.
Not all modules of this library are relevant to gain an understanding of how
it functions, the next part to go to at this point is
"Database.HaskRel.RDBMS", and the modules it reexports.
.
[1] <http://shop.oreilly.com/product/0636920022879.do SQL and Relational Theory, 2nd ed. (2011), C.J. Date>
[2] <http://www.dcs.warwick.ac.uk/~hugh/TTM/TTM-2013-02-07.pdf The Third Manifesto, C. J. Date and Hugh Darwen, February 7th, 2013>
license: GPL-2
license-file: LICENSE
author: Thor Michael Støre
maintainer: thormichael@gmail.com
copyright: Thor Michael Støre 2015
category: Database
build-type: Simple
extra-source-files: examples/*.hs, examples/*.sh, examples/SuppliersPartsDB/*.hs
data-files: README.md, examples/SuppliersPartsDB/README.md,
examples/SuppliersPartsDB/*.rv
cabal-version: >=1.10
tested-with: GHC==7.10.2
source-repository head
type: git
location: https://github.com/thormick/HaskRel
library
exposed-modules: Database.HaskRel.RDBMS,
Database.HaskRel.FWTabulation,
Database.HaskRel.HFWTabulation,
Database.HaskRel.Order,
Database.HaskRel.Support,
Database.HaskRel.Relational.Algebra,
Database.HaskRel.Relational.Assignment,
Database.HaskRel.Relational.Definition,
Database.HaskRel.Relational.Expression,
Database.HaskRel.Relational.Unicode,
Database.HaskRel.Relational.Variable
default-extensions: DataKinds
other-extensions: TypeOperators, FlexibleContexts, ScopedTypeVariables,
PolyKinds, TypeFamilies, FlexibleInstances,
MultiParamTypeClasses, UndecidableInstances,
KindSignatures
build-depends: base >=4.8 && <4.9, HList >=0.4 && <0.5,
containers >=0.5 && <0.6, tagged >=0.8 && <0.9,
directory >=1.2 && <1.3, ghc-prim >=0.4 && <0.5
hs-source-dirs: src
default-language: Haskell2010