Haskell types that can be represented as expressions in a database. There should be an instance of DBType for all column types in your database schema (e.g., int, timestamptz, etc).

Rel8 comes with stock instances for most default types in PostgreSQL, so you should only need to derive instances of this class for custom database types, such as types defined in PostgreSQL extensions, or custom domain types.

A deriving-via helper type for column types that store a Haskell value using a JSON encoding described by aeson's ToJSON and FromJSON type classes.

Like JSONEncoded, but works for jsonb columns.

A deriving-via helper type for column types that store a Haskell value using a Haskell's Read and Show type classes.

A deriving-via helper type for column types that store a Haskell product type in a single Postgres column using a Postgres composite type.

Note that this must map to a specific extant type in your database's schema (created with CREATE TYPE). Use DBComposite to specify the name of this Postgres type and the names of the individual fields (for projecting with decompose).

DBComposite is used to associate composite type metadata with a Haskell type.

Collapse a HKD into a PostgreSQL composite type.

HKD values are represented in queries by having a column for each field in the corresponding Haskell type. compose collapses these columns into a single column expression, by combining them into a PostgreSQL composite type.

Expand a composite type into a HKD.

decompose is the inverse of compose.

A deriving-via helper type for column types that store an "enum" type (in Haskell terms, a sum type where all constructors are nullary) using a Postgres enum type.

Note that this should map to a specific type in your database's schema (explicitly created with CREATE TYPE ... AS ENUM). Use DBEnum to specify the name of this Postgres type and the names of the individual values. If left unspecified, the names of the values of the Postgres enum are assumed to match exactly exactly the names of the constructors of the Haskell type (up to and including case sensitivity).

DBEnum contains the necessary metadata to describe a PostgreSQL enum type.

Types that are sum types, where each constructor is unary (that is, has no fields).

TypeInformation describes how to encode and decode a Haskell type to and from database queries. The typeName is the name of the type in the database, which is used to accurately type literals.

A PostgreSQL type consists of a QualifiedName (name, schema), and optional modifiers and arrayDepth. modifiers will usually be [], but a type like numeric(6, 2) will have ["6", "2"]. arrayDepth is always 0 for non-array types.

Simultaneously map over how a type is both encoded and decoded, while retaining the name of the type. This operation is useful if you want to essentially newtype another DBType.

The mapping is required to be total. If you have a partial mapping, see parseTypeInformation.

Apply a parser to TypeInformation.

This can be used if the data stored in the database should only be subset of a given TypeInformation. The parser is applied when deserializing rows returned - the encoder assumes that the input data is already in the appropriate form.

The class of DBTypes that form a semigroup. This class is purely a Rel8 concept, and exists to mirror the Semigroup class.

The class of DBTypes that form a semigroup. This class is purely a Rel8 concept, and exists to mirror the Monoid class.

The class of database types that support the +, *, - operators, and the abs, negate, sign functions.

The class of database types that can be coerced to from integral expressions. This is a Rel8 concept, and allows us to provide fromIntegral.

The class of database types that support the / operator.

The class of database types that support the / operator.

This type class allows you to define custom Tables using higher-kinded data types. Higher-kinded data types are data types of the pattern:

data MyType f =
  MyType { field1 :: Column f T1 OR HK1 f
         , field2 :: Column f T2 OR HK2 f
         , ...
         , fieldN :: Column f Tn OR HKn f
         }

where Tn is any Haskell type, and HKn is any higher-kinded type.

That is, higher-kinded data are records where all fields in the record are all either of the type Column f T (for any T), or are themselves higher-kinded data:

Nested

data Nested f =
  Nested { nested1 :: MyType f
         , nested2 :: MyType f
         }

The Rel8able type class is used to give us a special mapping operation that lets us change the type parameter f.

Supplying Rel8able instances

This type class should be derived generically for all table types in your project. To do this, enable the DeriveAnyClass and DeriveGeneric language extensions:

{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}

data MyType f = MyType { fieldA :: Column f T }
  deriving ( GHC.Generics.Generic, Rel8able )

The kind of Rel8able types

This type family is used to specify columns in Rel8ables. In Column f a, f is the context of the column (which should be left polymorphic in Rel8able definitions), and a is the type of the column.

Nest an Either value within a Rel8able. HEither f a b will produce a EitherTable a b in the Expr context, and a Either a b in the Result context.

Nest a Maybe value within a Rel8able. HMaybe f a will produce a MaybeTable a in the Expr context, and a Maybe a in the Result context.

Nest a list within a Rel8able. HList f a will produce a ListTable a in the Expr context, and a [a] in the Result context.

Nest a NonEmpty list within a Rel8able. HNonEmpty f a will produce a NonEmptyTable a in the Expr context, and a NonEmpty a in the Result context.

Nest a Null value within a Rel8able. HNull f a will produce a NullTable a in the Expr context, and a Maybe a in the Result context.

Nest an These value within a Rel8able. HThese f a b will produce a TheseTable a b in the Expr context, and a These a b in the Result context.

Tables are one of the foundational elements of Rel8, and describe data types that have a finite number of columns. Each of these columns contains data under a shared context, and contexts describe how to interpret the metadata about a column to a particular Haskell type. In Rel8, we have contexts for expressions (the Expr context), aggregations (the Aggregate context), insert values (the Insert context), among others.

In typical usage of Rel8 you don't need to derive instances of Table yourself, as anything that's an instance of Rel8able is always a Table.