Squeal.PostgreSQL.Schema

A type-level DSL for kinds of PostgreSQL types, constraints, and aliases.

Types

data PGType

PGType is the promoted datakind of PostgreSQL types.

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

Constructors

PGbool

logical Boolean (true/false)

PGint2

signed two-byte integer

PGint4

signed four-byte integer

PGint8

signed eight-byte integer

PGnumeric

arbitrary precision numeric type

PGfloat4

single precision floating-point number (4 bytes)

PGfloat8

double precision floating-point number (8 bytes)

PGchar Nat

fixed-length character string

PGvarchar Nat

variable-length character string

PGtext

variable-length character string

PGbytea

binary data ("byte array")

PGtimestamp

date and time (no time zone)

PGtimestamptz

date and time, including time zone

PGdate

calendar date (year, month, day)

PGtime

time of day (no time zone)

PGtimetz

time of day, including time zone

PGinterval

time span

PGuuid

universally unique identifier

PGinet

IPv4 or IPv6 host address

PGjson

textual JSON data

PGjsonb

binary JSON data, decomposed

PGvararray PGType

variable length array

PGfixarray Nat PGType

fixed length array

UnsafePGType Symbol

an escape hatch for unsupported PostgreSQL types

Instances

PGAvg PGType PGint2 PGnumeric

Methods

avg :: Expression relations Ungrouped params (nullity PGnumeric) -> Expression relations (Grouped bys) params (nullity avg)

avgDistinct :: Expression relations Ungrouped params (nullity PGnumeric) -> Expression relations (Grouped bys) params (nullity avg)

PGAvg PGType PGint4 PGnumeric

Methods

avg :: Expression relations Ungrouped params (nullity PGnumeric) -> Expression relations (Grouped bys) params (nullity avg)

avgDistinct :: Expression relations Ungrouped params (nullity PGnumeric) -> Expression relations (Grouped bys) params (nullity avg)

PGAvg PGType PGint8 PGnumeric

Methods

avg :: Expression relations Ungrouped params (nullity PGnumeric) -> Expression relations (Grouped bys) params (nullity avg)

avgDistinct :: Expression relations Ungrouped params (nullity PGnumeric) -> Expression relations (Grouped bys) params (nullity avg)

PGAvg PGType PGnumeric PGnumeric

Methods

avg :: Expression relations Ungrouped params (nullity PGnumeric) -> Expression relations (Grouped bys) params (nullity avg)

avgDistinct :: Expression relations Ungrouped params (nullity PGnumeric) -> Expression relations (Grouped bys) params (nullity avg)

PGAvg PGType PGfloat4 PGfloat8

Methods

avg :: Expression relations Ungrouped params (nullity PGfloat8) -> Expression relations (Grouped bys) params (nullity avg)

avgDistinct :: Expression relations Ungrouped params (nullity PGfloat8) -> Expression relations (Grouped bys) params (nullity avg)

PGAvg PGType PGfloat8 PGfloat8

Methods

avg :: Expression relations Ungrouped params (nullity PGfloat8) -> Expression relations (Grouped bys) params (nullity avg)

avgDistinct :: Expression relations Ungrouped params (nullity PGfloat8) -> Expression relations (Grouped bys) params (nullity avg)

PGAvg PGType PGinterval PGinterval

Methods

avg :: Expression relations Ungrouped params (nullity PGinterval) -> Expression relations (Grouped bys) params (nullity avg)

avgDistinct :: Expression relations Ungrouped params (nullity PGinterval) -> Expression relations (Grouped bys) params (nullity avg)

class HasOid (ty :: PGType) where

The object identifier of a PGType.

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

Minimal complete definition

oid

Methods

oid :: Word32

Instances

HasOid PGbool

Methods

oid :: Word32

HasOid PGint2

Methods

oid :: Word32

HasOid PGint4

Methods

oid :: Word32

HasOid PGint8

Methods

oid :: Word32

HasOid PGnumeric

Methods

oid :: Word32

HasOid PGfloat4

Methods

oid :: Word32

HasOid PGfloat8

Methods

oid :: Word32

HasOid PGtext

Methods

oid :: Word32

HasOid PGbytea

Methods

oid :: Word32

HasOid PGtimestamp

Methods

oid :: Word32

HasOid PGtimestamptz

Methods

oid :: Word32

HasOid PGdate

Methods

oid :: Word32

HasOid PGtime

Methods

oid :: Word32

HasOid PGtimetz

Methods

oid :: Word32

HasOid PGinterval

Methods

oid :: Word32

HasOid PGuuid

Methods

oid :: Word32

HasOid PGinet

Methods

oid :: Word32

HasOid PGjson

Methods

oid :: Word32

HasOid PGjsonb

Methods

oid :: Word32

HasOid (PGchar n)

Methods

oid :: Word32

HasOid (PGvarchar n)

Methods

oid :: Word32

data NullityType

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

Constructors

Null PGType

NULL may be present

NotNull PGType

NULL is absent

Instances

Category TablesType Definition

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

(KnownNat n, HasParameter ((-) n 1) params ty) => HasParameter n ((:) NullityType ty' params) ty

Methods

param :: Expression relations grouping ((NullityType ': ty') params) ty

PGTyped (PGTypeOf ty1) => HasParameter 1 ((:) NullityType ty1 tys) ty1

Methods

param :: Expression relations grouping ((NullityType ': ty1) tys) ty1

(~) FieldName field column => SameField (FieldInfo field) ((:::) NullityType column ty)

FromValue pg y => FromColumnValue ((:::) NullityType column (NotNull pg)) y

Methods

fromColumnValue :: K (Symbol, NullityType) (Maybe ByteString) ((NullityType ::: column) (NotNull pg)) -> y

FromValue pg y => FromColumnValue ((:::) NullityType column (Null pg)) (Maybe y)

Methods

fromColumnValue :: K (Symbol, NullityType) (Maybe ByteString) ((NullityType ::: column) (Null pg)) -> Maybe y

AddColumn ((:=>) ColumnConstraint NullityType Def ty)

Methods

addColumn :: KnownSymbol column => Alias column -> TypeExpression ((ColumnConstraint :=> NullityType) Def ty) -> AlterTable schema ((TableConstraints :=> ColumnsType) constraints columns) ((TableConstraints :=> [(Symbol, ColumnType)]) constraints (Create ColumnType column ((ColumnConstraint :=> NullityType) Def ty) columns))

AddColumn ((:=>) ColumnConstraint NullityType NoDef (Null ty))

Methods

addColumn :: KnownSymbol column => Alias column -> TypeExpression ((ColumnConstraint :=> NullityType) NoDef (Null ty)) -> AlterTable schema ((TableConstraints :=> ColumnsType) constraints columns) ((TableConstraints :=> [(Symbol, ColumnType)]) constraints (Create ColumnType column ((ColumnConstraint :=> NullityType) NoDef (Null ty)) columns))

type ColumnType = (ColumnConstraint, 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

type ColumnsType = [(Symbol, ColumnType)]

ColumnsType is a row of ColumnTypes.

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

type RelationType = [(Symbol, NullityType)]

RelationType is a row of NullityType

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

type family NilRelation :: RelationType where ...

A monokinded empty RelationType.

Equations

NilRelation = '[]

type RelationsType = [(Symbol, RelationType)]

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

type TableType = (TableConstraints, ColumnsType)

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

type TablesType = [(Symbol, TableType)]

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

type family NilTables :: TablesType where ...

A monokinded empty TablesType.

Equations

NilTables = '[]

Grouping

data Grouping

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

Constructors

Ungrouped

no aggregation permitted

Grouped [(Symbol, Symbol)]

aggregation required for any column which is not grouped

class (KnownSymbol relation, KnownSymbol column) => GroupedBy relation column bys

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.

Instances

(KnownSymbol relation, KnownSymbol column) => GroupedBy [(k, Symbol)] relation column ((:) (k, Symbol) ((,) k Symbol table column) bys)

(KnownSymbol relation, KnownSymbol column, GroupedBy [a] relation column bys) => GroupedBy [a] relation column ((:) a tabcol bys)

Constraints

type (:=>) constraint ty = '(constraint, ty) infixr 7

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.

data ColumnConstraint

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.

Constructors

Def

DEFAULT is available for inserts and updates

NoDef

DEFAULT is unavailable for inserts and updates

Instances

Category TablesType Definition

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

AddColumn ((:=>) ColumnConstraint NullityType Def ty)

Methods

addColumn :: KnownSymbol column => Alias column -> TypeExpression ((ColumnConstraint :=> NullityType) Def ty) -> AlterTable schema ((TableConstraints :=> ColumnsType) constraints columns) ((TableConstraints :=> [(Symbol, ColumnType)]) constraints (Create ColumnType column ((ColumnConstraint :=> NullityType) Def ty) columns))

AddColumn ((:=>) ColumnConstraint NullityType NoDef (Null ty))

Methods

addColumn :: KnownSymbol column => Alias column -> TypeExpression ((ColumnConstraint :=> NullityType) NoDef (Null ty)) -> AlterTable schema ((TableConstraints :=> ColumnsType) constraints columns) ((TableConstraints :=> [(Symbol, ColumnType)]) constraints (Create ColumnType column ((ColumnConstraint :=> NullityType) NoDef (Null ty)) columns))

data TableConstraint

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.

Constructors

Check [Symbol]

Unique [Symbol]

PrimaryKey [Symbol]

ForeignKey [Symbol] Symbol [Symbol]

Instances

Category TablesType Definition

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

type TableConstraints = [(Symbol, TableConstraint)]

A TableConstraints is a row of TableConstraints.

type family NilTableConstraints :: TableConstraints where ...

A monokinded empty TableConstraints.

Equations

NilTableConstraints = '[]

Aliases

type (:::) (alias :: Symbol) ty = '(alias, ty) infixr 6

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.

data Alias (alias :: Symbol)

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

Constructors

Alias

Instances

IsQualified table column (Alias table, Alias column)

Methods

(!) :: Alias table -> Alias column -> (Alias table, Alias column)

(~) Symbol alias1 alias2 => IsLabel alias1 (Alias alias2)

Methods

fromLabel :: Alias alias2

Eq (Alias alias)

Methods

(==) :: Alias alias -> Alias alias -> Bool

(/=) :: Alias alias -> Alias alias -> Bool

Ord (Alias alias)

Methods

compare :: Alias alias -> Alias alias -> Ordering

(<) :: Alias alias -> Alias alias -> Bool

(<=) :: Alias alias -> Alias alias -> Bool

(>) :: Alias alias -> Alias alias -> Bool

(>=) :: Alias alias -> Alias alias -> Bool

max :: Alias alias -> Alias alias -> Alias alias

min :: Alias alias -> Alias alias -> Alias alias

Show (Alias alias)

Methods

showsPrec :: Int -> Alias alias -> ShowS

show :: Alias alias -> String

showList :: [Alias alias] -> ShowS

Generic (Alias alias)

Associated Types

type Rep (Alias alias) :: * -> *

Methods

from :: Alias alias -> Rep (Alias alias) x

to :: Rep (Alias alias) x -> Alias alias

NFData (Alias alias)

Methods

rnf :: Alias alias -> ()

type Rep (Alias alias)

type Rep (Alias alias) = D1 * (MetaData "Alias" "Squeal.PostgreSQL.Schema" "squeal-postgresql-0.2.1.0-LBCcz8qiN2YKV8JaWeUPNP" False) (C1 * (MetaCons "Alias" PrefixI False) (U1 *))

renderAlias :: KnownSymbol alias => Alias alias -> ByteString

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

data Aliased expression aliased where

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

Constructors

As :: KnownSymbol alias => expression ty -> Alias alias -> Aliased expression (alias ::: ty)

Instances

Eq (expression ty) => Eq (Aliased k expression ((:::) k alias ty))

Methods

(==) :: Aliased k expression ((k ::: alias) ty) -> Aliased k expression ((k ::: alias) ty) -> Bool

(/=) :: Aliased k expression ((k ::: alias) ty) -> Aliased k expression ((k ::: alias) ty) -> Bool

Ord (expression ty) => Ord (Aliased k expression ((:::) k alias ty))

Methods

compare :: Aliased k expression ((k ::: alias) ty) -> Aliased k expression ((k ::: alias) ty) -> Ordering

(<) :: Aliased k expression ((k ::: alias) ty) -> Aliased k expression ((k ::: alias) ty) -> Bool

(<=) :: Aliased k expression ((k ::: alias) ty) -> Aliased k expression ((k ::: alias) ty) -> Bool

(>) :: Aliased k expression ((k ::: alias) ty) -> Aliased k expression ((k ::: alias) ty) -> Bool

(>=) :: Aliased k expression ((k ::: alias) ty) -> Aliased k expression ((k ::: alias) ty) -> Bool

max :: Aliased k expression ((k ::: alias) ty) -> Aliased k expression ((k ::: alias) ty) -> Aliased k expression ((k ::: alias) ty)

min :: Aliased k expression ((k ::: alias) ty) -> Aliased k expression ((k ::: alias) ty) -> Aliased k expression ((k ::: alias) ty)

Show (expression ty) => Show (Aliased k expression ((:::) k alias ty))

Methods

showsPrec :: Int -> Aliased k expression ((k ::: alias) ty) -> ShowS

show :: Aliased k expression ((k ::: alias) ty) -> String

showList :: [Aliased k expression ((k ::: alias) ty)] -> ShowS

renderAliasedAs :: (forall ty. expression ty -> ByteString) -> Aliased expression aliased -> ByteString

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

type family AliasesOf aliaseds where ...

AliasesOf retains the AliasesOf in a row.

Equations

AliasesOf '[] = '[]

AliasesOf ((alias ::: ty) ': tys) = alias ': AliasesOf tys

class KnownSymbol alias => Has (alias :: Symbol) (fields :: [(Symbol, kind)]) (field :: kind) | alias fields -> field

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

Instances

(KnownSymbol alias, Has kind alias fields field) => Has kind alias ((:) (Symbol, kind) field' fields) field

KnownSymbol alias => Has kind alias ((:) (Symbol, kind) ((:::) kind alias field) fields) field

type HasUnique alias fields field = fields ~ '[alias ::: field]

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

class IsLabel (x :: Symbol) a where

Minimal complete definition

fromLabel

Methods

fromLabel :: a

Instances

(~) Symbol alias1 alias2 => IsLabel alias1 (Alias alias2)

Methods

fromLabel :: Alias alias2

(Has TableType alias schema table, (~) RelationType relation (ColumnsToRelation (TableToColumns table))) => IsLabel alias (Table schema relation)

Methods

fromLabel :: Table schema relation

(HasUnique [(Symbol, NullityType)] relation relations columns, Has NullityType column columns ty, GroupedBy [(Symbol, Symbol)] relation column bys) => IsLabel column (Expression relations (Grouped bys) params ty)

Methods

fromLabel :: Expression relations (Grouped bys) params ty

(HasUnique [(Symbol, NullityType)] relation relations columns, Has NullityType column columns ty) => IsLabel column (Expression relations Ungrouped params ty)

Methods

fromLabel :: Expression relations Ungrouped params ty

class IsQualified table column expression where

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

Minimal complete definition

(!)

Methods

(!) :: Alias table -> Alias column -> expression infixl 9

Instances

IsQualified table column (Alias table, Alias column)

Methods

(!) :: Alias table -> Alias column -> (Alias table, Alias column)

(Has [(Symbol, NullityType)] relation relations columns, Has NullityType column columns ty, GroupedBy [(Symbol, Symbol)] relation column bys) => IsQualified relation column (Expression relations (Grouped bys) params ty)

Methods

(!) :: Alias relation -> Alias column -> Expression relations (Grouped bys) params ty

(Has [(Symbol, NullityType)] relation relations columns, Has NullityType column columns ty) => IsQualified relation column (Expression relations Ungrouped params ty)

Methods

(!) :: Alias relation -> Alias column -> Expression relations Ungrouped params ty

Type Families

type family Join xs ys where ...

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

Equations

Join '[] ys = ys

Join (x ': xs) ys = x ': Join xs ys

type family Create alias x xs where ...

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

Equations

Create alias x '[] = '[alias ::: x]

Create alias y (x ': xs) = x ': Create alias y xs

type family Drop alias xs where ...

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

Equations

Drop alias ((alias ::: x) ': xs) = xs

Drop alias (x ': xs) = x ': Drop alias xs

type family Alter alias xs x where ...

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

Equations

Alter alias ((alias ::: x0) ': xs) x1 = (alias ::: x1) ': xs

Alter alias (x0 ': xs) x1 = x0 ': Alter alias xs x1

type family Rename alias0 alias1 xs where ...

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

Equations

Rename alias0 alias1 ((alias0 ::: x0) ': xs) = (alias1 ::: x0) ': xs

Rename alias0 alias1 (x ': xs) = x ': Rename alias0 alias1 xs

type family Elem x xs where ...

Elem is a promoted elem.

Equations

Elem x '[] = False

Elem x (x ': xs) = True

Elem x (_ ': xs) = Elem x xs

type family In x xs :: Constraint where ...

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

Equations

In x xs = Elem x xs ~ True

type PGNum ty = In ty '[PGint2, PGint4, PGint8, PGnumeric, PGfloat4, PGfloat8]

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

type PGIntegral ty = In ty '[PGint2, PGint4, PGint8]

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

type PGFloating ty = In ty '[PGfloat4, PGfloat8, PGnumeric]

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

type family PGTypeOf (ty :: NullityType) :: PGType where ...

PGTypeOf forgets about NULL and any column constraints.

Equations

PGTypeOf (nullity pg) = pg

type family SameTypes (columns0 :: ColumnsType) (columns1 :: ColumnsType) :: Constraint where ...

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

Equations

SameTypes '[] '[] = ()

SameTypes ((column0 ::: (def0 :=> ty0)) ': columns0) ((column1 ::: (def1 :=> ty1)) ': columns1) = (ty0 ~ ty1, SameTypes columns0 columns1)

type family AllNotNull (columns :: ColumnsType) :: Constraint where ...

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

Equations

AllNotNull '[] = ()

AllNotNull ((column ::: (def :=> NotNull ty)) ': columns) = AllNotNull columns

type family NotAllNull (columns :: ColumnsType) :: Constraint where ...

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

Equations

NotAllNull ((column ::: (def :=> NotNull ty)) ': columns) = ()

NotAllNull ((column ::: (def :=> Null ty)) ': columns) = NotAllNull columns

type family NullifyType (ty :: NullityType) :: NullityType where ...

NullifyType is an idempotent that nullifies a ColumnType.

Equations

NullifyType (Null ty) = Null ty

NullifyType (NotNull ty) = Null ty

type family NullifyRelation (columns :: RelationType) :: RelationType where ...

NullifyRelation is an idempotent that nullifies a ColumnsType.

Equations

NullifyRelation '[] = '[]

NullifyRelation ((column ::: ty) ': columns) = (column ::: NullifyType ty) ': NullifyRelation columns

type family NullifyRelations (tables :: RelationsType) :: RelationsType where ...

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

Equations

NullifyRelations '[] = '[]

NullifyRelations ((table ::: columns) ': tables) = (table ::: NullifyRelation columns) ': NullifyRelations tables

type family ColumnsToRelation (columns :: ColumnsType) :: RelationType where ...

ColumnsToRelation removes column constraints.

Equations

ColumnsToRelation '[] = '[]

ColumnsToRelation ((column ::: (constraint :=> ty)) ': columns) = (column ::: ty) ': ColumnsToRelation columns

type family RelationToColumns (relation :: RelationType) :: ColumnsType where ...

RelationToColumns adds `NoDef column constraints.

Equations

RelationToColumns '[] = '[]

RelationToColumns ((column ::: ty) ': columns) = (column ::: (NoDef :=> ty)) ': RelationToColumns columns

type family TableToColumns (table :: TableType) :: ColumnsType where ...

TableToColumns removes table constraints.

Equations

TableToColumns (constraints :=> columns) = columns

type family TablesToRelations (tables :: TablesType) :: RelationsType where ...

TablesToRelations removes both table and column constraints.

Equations

TablesToRelations '[] = '[]

TablesToRelations ((alias ::: (constraint :=> columns)) ': tables) = (alias ::: ColumnsToRelation columns) ': TablesToRelations tables

type family RelationsToTables (tables :: RelationsType) :: TablesType where ...

RelationsToTables adds both trivial table and column constraints.

Equations

RelationsToTables '[] = '[]

RelationsToTables ((alias ::: columns) ': relations) = (alias ::: ('[] :=> RelationToColumns columns)) ': RelationsToTables relations

type family ConstraintInvolves column constraint where ...

Check if a TableConstraint involves a column

Equations

ConstraintInvolves column (Check columns) = column `Elem` columns

ConstraintInvolves column (Unique columns) = column `Elem` columns

ConstraintInvolves column (PrimaryKey columns) = column `Elem` columns

ConstraintInvolves column (ForeignKey columns tab refcolumns) = column `Elem` columns

type family DropIfConstraintsInvolve column constraints where ...

Drop all TableConstraints that involve a column

Equations

DropIfConstraintsInvolve column '[] = '[]

DropIfConstraintsInvolve column ((alias ::: constraint) ': constraints) = If (ConstraintInvolves column constraint) (DropIfConstraintsInvolve column constraints) ((alias ::: constraint) ': DropIfConstraintsInvolve column constraints)

Generics

class SameField (fieldInfo :: FieldInfo) (fieldty :: (Symbol, NullityType))

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

Instances

(~) FieldName field column => SameField (FieldInfo field) ((:::) NullityType column ty)

type family SameFields (datatypeInfo :: DatatypeInfo) (columns :: RelationType) :: Constraint where ...

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

Equations

SameFields (ADT _module _datatype '[Record _constructor fields]) columns = AllZip SameField fields columns

SameFields (Newtype _module _datatype (Record _constructor fields)) columns = AllZip SameField fields columns