Rename multiple attributes of a relation.

>>> let pnu = Label :: Label "pnu"
>>> let colour = Label :: Label "colour"
>>> rPrint$ p' `rename` nAs( pno `as` pnu, color `as` colour )
┌─────┬───────┬────────┬────────┬────────┐
│ pnu │ pName │ colour │ weight │ city   │
╞═════╪═══════╪════════╪════════╪════════╡
│ P1  │ Nut   │ Red    │ 12 % 1 │ London │
...

Extends the given relation with the r-tuple resulting from the second argument. Existing attributes with the same name will be replaced.

See extend.

Restricts the given relation according to the given predicate. Note that this is the well known WHERE operator of both SQL and Tutorial D, but since "where" is a reserved keyword in Haskell it is named "restrict".

See restrict.

Projects the given relation on the given heading.

See project.

Projects the given relation on the heading of said given relation minus the given heading.

See projectAllBut.

Performs a natural join of the two given relations.

See naturalJoin.

Alias of naturalJoin.

See nJoin.

The cartesian product of two relations. A specialized natural join; the natural join between two relations with disjoint headings.

See times.

Performs a semi-join of the first given relation against the second given relation.

See matching.

Alias of matching. See semiJoin.

Performs a semi-difference of the first given relation against the second given relation.

Aka. antijoin:

Also known, a trifle inappropriately, as antijoin.

• Chris Date 2011, SQL and Relational Theory 2nd ed. p. 133

See notMatching.

Alias of notMatching. See semiDiff.

Performs a union of the given relations.

See union.

Performs a disjoint union between the two relvars. This is a union of disjoint relations, where a runtime error is raised if the operands are not disjoint.

See dUnion.

The intersection of two relations.

Note how the name is different from Data.Set, where the comparable function is named "intersection". This is due to it being referred to as "intersect" in material describing the relational model; specifically named "INTERSECT" in Tutorial D.

See intersect.

The difference of two relations.

The "minus" term is used in material describing relational theory; specifically Tutorial D names the operator "MINUS".

See minus.

Exclusive union, aka. symmetric difference.

See xUnion.

Groups the given attributes of the given relation into a given new relation valued attribute.

As the Tutorial D GROUP operator, not SQL GROUP BY.

See group.

Groups the given relation on all but the given attributes into a given new attribute.

See groupAllBut.

Ungroups the given attribute of the given relation.

>>> let pq = (Label :: Label "pq")
>>> sp' == ungroup ( group sp' (rHdr (pno,qty)) (pq .=.)) pq
True

Note the difference to ungroup, which requires rEq for relational comparison.

Summarize.

See summarize.

Performs a natural join between two relations with intersecting headings. A specialized natural join.

A join upon relations r1, r2 where the intersection of the heading of r1 and of r2 is not empty; the headings are not disjoint. This is the complement of times that together with it forms a natural join; all that would be disallowed for times is allowed here and vice-versa. The name is what I quickly settled on, suggestions for a better one would be welcome. (Attribute-Intersecting Natural Join is another candidate.)

This function doesn't have a specific identity value, although it holds that r `interJoin` r = r

See interJoin.

Alias of interJoin. See iJoin.

Disjoint extension. Extends the given relation with the result of the second argument, as extend, but without deleting any that exist.

See dExtend.

Auto-summarization. A specialization of summarize with the same source and destination relation.

See aSummarize.

Extends the first given relation with an attribute resulting from imaging each tuple of said relation against the second given relation. This gives a superset of the information given by SQL RIGHT OUTER JOIN.

See imageExtendL.

The difference of two relations. This differs from minus in that the attribute order of the second argument takes precedence, which is neccessary to swap precedence since minus is non-commutative. This function is as such equal to minus as far as relational theory is concerned, the difference is on a lower level of abstraction.

Extends the given relation with the attribute resulting from the second argument. If an attribute with the same name exists then it will be replaced. This allows for the function of the second argument to be simpler.

See extendA.

Disjoint extension of a single attribute. Extends the given relation with the result of the second argument, as extend, but without deleting any that exist. l cannot already have any attribute e.

See dExtendA.

Renames a single attribute. See renameA

Tests whether the second argument is a proper subset of the first.

See isProperSubsetOf.

Tests whether the second argument is a subset of the first.

See isSubsetOf.

The image of a relation corresponding to an r-tuple.

An application of the first argument only, an r-tuple, to this function yields what is known as the !! operator in Tutorial D.

>>> let qtySum = Label::Label "qtySum"
>>> :{
    rPrint$ s'
            `project` (rHdr (sno))
            `extendA` (\ (image -> ii) ->
                            qtySum .=.
                                ( sum $ aggU $ ii ( sp' `project` (rHdr (sno,qty)) ) ) )
 :}

See image.

Gives the cardinality of the argument.

Gives whether the given argument is empty or not.

Right-fold of an attribute of a relation (although a "right" fold doesn't make sense in the context of the relational model). Note that the value of the third argument, att, is not used and may be "undefined".

See rafoldr.

Right-fold of the attribute of a unary relation.

See rafoldrU.

Attribute value aggregation, a specialization of rafoldr that aggregates the values of a single attribute into a list of the values the attribute type wraps.

Note that the value of the first argument, att, is not used and may be "undefined".

>>> sum $ agg qty sp'
3100

See agg.

Aggregation of the single attribute of a unary relation. A specialization of agg, and thus in turn of rafoldr, that aggregates the single attribute of a unary relation, without requiring the name of that attribute.

>>> sum $ aggU $ sp' `project` (rHdr (qty))
1000

See aggU.

Rearrange a set of HList records to context. From the perspective of relational theory this is a presentation function.

Failure class restricting a type-level operation to a non-empty result.