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
     ]
:}

TablesType is a row of TableTypes, thought of as a union.

>>> :{
type family Schema :: TablesType where
  Schema =
    '[ "users" :::
         '[ "pk_users" ::: 'PrimaryKey '["id"] ] :=>
         '[ "id" ::: 'Def :=> 'NotNull 'PGint4
          , "name" ::: 'NoDef :=> 'NotNull 'PGtext
          , "vec" ::: 'NoDef :=> 'NotNull ('PGvararray 'PGint2)
          ]
     , "emails" :::
         '[  "pk_emails" ::: 'PrimaryKey '["id"]
          , "fk_user_id" ::: 'ForeignKey '["user_id"] "users" '["id"]
          ] :=>
         '[ "id" ::: 'Def :=> 'NotNull 'PGint4
          , "user_id" ::: 'NoDef :=> 'NotNull 'PGint4
          , "email" ::: 'NoDef :=> 'Null 'PGtext
          ]
     ]
:}

A monokinded empty TablesType.

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.

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.

The alias operator ::: is like a promoted version of As, a type level pair between an alias and some type, like a column alias and either a ColumnType or NullityType or a table alias and either a TableType or a RelationType or a constraint alias and a TableConstraint.

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"

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

>>> 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.

Has alias fields field is a constraint that proves that fields has a field of alias ::: field.

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

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

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

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 xs x 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.

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.

RelationToColumns adds `NoDef column constraints.

TableToColumns removes table constraints.

TablesToRelations removes both table and column constraints.

RelationsToTables adds both trivial table and column constraints.

Check if a TableConstraint involves a column

Drop all TableConstraints that involve a column

A SameField constraint is an equality constraint on a FieldInfo and the column alias in a ::: pair.

A SameFields constraint proves that a DatatypeInfo of a record type has the same field names as the column AliasesOf of a ColumnsType.