PGType is the promoted datakind of PostgreSQL types.

>>> import Squeal.PostgreSQL.Schema
>>> :kind 'PGbool
'PGbool :: PGType

The object identifier of a PGType.

>>> :set -XTypeApplications
>>> oid @'PGbool
16

NullityType encodes the potential presence or definite absence of a NULL allowing operations which are sensitive to such to be well typed.

>>> :kind 'Null 'PGint4
'Null 'PGint4 :: NullityType
>>> :kind 'NotNull ('PGvarchar 50)
'NotNull ('PGvarchar 50) :: NullityType

ColumnType encodes the allowance of DEFAULT and NULL and the base PGType for a column.

>>> :set -XTypeFamilies -XTypeInType
>>> import GHC.TypeLits
>>> type family IdColumn :: ColumnType where IdColumn = 'Def :=> 'NotNull 'PGint4
>>> type family EmailColumn :: ColumnType where EmailColumn = 'NoDef :=> 'Null 'PGtext

ColumnsType is a row of ColumnTypes.

>>> :{
type family UsersColumns :: ColumnsType where
  UsersColumns =
    '[ "name" ::: 'NoDef :=> 'NotNull 'PGtext
     , "id"   :::   'Def :=> 'NotNull 'PGint4
     ]
:}

RelationType is a row of NullityType

>>> :{
type family PersonRelation :: RelationType where
  PersonRelation =
    '[ "name"        ::: 'NotNull 'PGtext
     , "age"         ::: 'NotNull 'PGint4
     , "dateOfBirth" :::    'Null 'PGdate
     ]
:}

A monokinded empty RelationType.

RelationsType is a row of RelationTypes, thought of as a product.

TableType encodes a row of constraints on a table as well as the types of its columns.

>>> :{
type family UsersTable :: TableType where
  UsersTable =
    '[ "pk_users" ::: 'PrimaryKey '["id"] ] :=>
    '[ "id"       :::   'Def :=> 'NotNull 'PGint4
     , "name"     ::: 'NoDef :=> 'NotNull 'PGtext
     ]
:}

A SchemumType is a user-defined type, either a Table, View or Typedef.

The schema of a database consists of a list of aliased, user-defined SchemumTypes.

The constraint operator, :=> is a type level pair between a "constraint" and some type, for use in pairing a ColumnConstraint with a NullityType to produce a ColumnType or a TableConstraints and a ColumnsType to produce a TableType.

ColumnConstraint encodes the availability of DEFAULT for inserts and updates. A column can be assigned a default value. A data Manipulation command can also request explicitly that a column be set to its default value, without having to know what that value is.

TableConstraint encodes various forms of data constraints of columns in a table. TableConstraints give you as much control over the data in your tables as you wish. If a user attempts to store data in a column that would violate a constraint, an error is raised. This applies even if the value came from the default value definition.

A TableConstraints is a row of TableConstraints.

A monokinded empty TableConstraints.

A ForeignKey must reference columns that either are a PrimaryKey or form a Unique constraint.

The alias operator ::: is like a promoted version of As, a type level pair between an alias and some type.

Aliases are proxies for a type level string or Symbol and have an IsLabel instance so that with -XOverloadedLabels

>>> :set -XOverloadedLabels
>>> #foobar :: Alias "foobar"
Alias

>>> renderAlias #jimbob
"\"jimbob\""

>>> import Generics.SOP (NP(..))
>>> renderAliases (#jimbob :* #kandi)
["\"jimbob\"","\"kandi\""]

The As operator is used to name an expression. As is like a demoted version of :::.

>>> Just "hello" `As` #hi :: Aliased Maybe ("hi" ::: String)
As (Just "hello") Alias

The Aliasable class provides a way to scrap your Nils in an NP list of Aliased expressions.

>>> let renderMaybe = fromString . maybe "Nothing" (const "Just")
>>> renderAliasedAs renderMaybe (Just (3::Int) `As` #an_int)
"Just AS \"an_int\""

AliasesOf retains the AliasesOf in a row.

The ZipAliased class provides a type family for zipping Symbol lists together with arbitrary lists of the same size, with an associated type family ZipAs, together with a method zipAs for zipping heterogeneous lists of Aliases together with a heterogeneous list of expressions into a heterogeneous list of Aliased expressions.

Has alias fields field is a constraint that proves that fields has a field of alias ::: field, inferring field from alias and fields.

HasUnique alias fields field is a constraint that proves that fields is a singleton of alias ::: field.

HasAll extends Has to take lists of aliases and fields and infer a list of subfields.

Analagous to IsLabel, the constraint IsQualified defines ! for a column alias qualified by a table alias.

IsPGlabel looks very much like the IsLabel class. Whereas the overloaded label, fromLabel is used for column references, labels are used for enum terms. A label is called with type application like `label @"beef"`.

A PGlabel unit type with an IsPGlabel instance

Renders a label

Renders a list of labels

Grouping is an auxiliary namespace, created by GROUP BY clauses (group), and used for typesafe aggregation

A GroupedBy constraint indicates that a table qualified column is a member of the auxiliary namespace created by GROUP BY clauses and thus, may be called in an output Expression without aggregating.

Join is simply promoted ++ and is used in JOINs in FromClauses.

Used in with.

Create alias x xs adds alias ::: x to the end of xs and is used in createTable statements and in ALTER TABLE addColumn.

Drop alias xs removes the type associated with alias in xs and is used in dropTable statements and in ALTER TABLE dropColumn statements.

Alter alias x xs replaces the type associated with an alias in xs with the type x and is used in alterTable and alterColumn.

Rename alias0 alias1 xs replaces the alias alias0 by alias1 in xs and is used in alterTableRename and renameColumn.

Elem is a promoted elem.

In x xs is a constraint that proves that x is in xs.

PGNum is a constraint on PGType whose Expressions have a Num constraint.

PGIntegral is a constraint on PGType whose Expressions have div_ and mod_ functions.

PGFloating is a constraint on PGType whose Expressions have Fractional and Floating constraints.

PGTypeOf forgets about NULL and any column constraints.

SameTypes is a constraint that proves two ColumnsTypes have the same length and the same ColumnTypes.

Equality constraint on the underlying PGType of two columns.

AllNotNull is a constraint that proves a ColumnsType has no NULLs.

NotAllNull is a constraint that proves a ColumnsType has some NOT NULL.

NullifyType is an idempotent that nullifies a ColumnType.

NullifyRelation is an idempotent that nullifies a ColumnsType.

NullifyRelations is an idempotent that nullifies a RelationsType used to nullify the left or right hand side of an outer join in a FromClause.

ColumnsToRelation removes column constraints.

TableToColumns removes table constraints.

Convert a table to a relation.

Check if a TableConstraint involves a column

Drop all TableConstraints that involve a column

The PG type family embeds a subset of Haskell types as Postgres basic types.

>>> :kind! PG LocalTime
PG LocalTime :: PGType
= 'PGtimestamp

The EnumFrom type family embeds Haskell enum types, ADTs with nullary constructors, as Postgres enum types

>>> data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic
>>> instance Generic Schwarma
>>> instance HasDatatypeInfo Schwarma
>>> :kind! EnumFrom Schwarma
EnumFrom Schwarma :: PGType
= 'PGenum '["Beef", "Lamb", "Chicken"]

The LabelsFrom type family calculates the constructors of a Haskell enum type.

>>> data Schwarma = Beef | Lamb | Chicken deriving GHC.Generic
>>> instance Generic Schwarma
>>> instance HasDatatypeInfo Schwarma
>>> :kind! LabelsFrom Schwarma
LabelsFrom Schwarma :: [Type.ConstructorName]
= '["Beef", "Lamb", "Chicken"]

The CompositeFrom type family embeds Haskell record types as Postgres composite types, as long as the record fields are Maybes of Haskell types that can be embedded as basic types with the PG type family.

>>> data Row = Row { a :: Maybe Int16, b :: Maybe LocalTime } deriving GHC.Generic
>>> instance Generic Row
>>> instance HasDatatypeInfo Row
>>> :kind! CompositeFrom Row
CompositeFrom Row :: PGType
= 'PGcomposite '['("a", 'PGint2), '("b", 'PGtimestamp)]

>>> data Row = Row { a :: Maybe Int16, b :: Maybe LocalTime } deriving GHC.Generic
>>> instance Generic Row
>>> instance HasDatatypeInfo Row
>>> :kind! FieldNamesFrom Row
FieldNamesFrom Row :: [Type.FieldName]
= '["a", "b"]

>>> data Row = Row { a :: Maybe Int16, b :: Maybe LocalTime } deriving GHC.Generic
>>> instance Generic Row
>>> instance HasDatatypeInfo Row
>>> :kind! FieldTypesFrom Row
FieldTypesFrom Row :: [PGType]
= '['PGint2, 'PGtimestamp]

Calculates constructors of a datatype.

Calculates the name of a nullary constructor, otherwise generates a type error.

Calculate the names of nullary constructors.

Calculate the fields of a datatype.

Calculate the name of a field.

Calculate the names of fields.

>>> :kind! FieldTypeOf (Maybe Int16)
FieldTypeOf (Maybe Int16) :: PGType
= 'PGint2

Calculate the types of fields.

Inspect the code of an algebraic datatype and ensure it's a product, otherwise generate a type error

MapMaybes is used in the binary instances of composite types.

Nulls is used to construct a row of a composite type.