Squeal.PostgreSQL.Schema

This module provides a type-level DSL for kinds of Postgres types, tables, schema, constraints, aliases, enumerated labels, and groupings. It also defines useful type families to operate on these. Finally, it defines an embedding of Haskell types into Postgres types.

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

PGenum [Symbol]

PGcomposite [(Symbol, PGType)]

UnsafePGType Symbol

an escape hatch for unsupported PostgreSQL types

Instances

PGAvg PGint2 PGnumeric

Defined in Squeal.PostgreSQL.Expression

Methods

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

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

PGAvg PGint4 PGnumeric

Defined in Squeal.PostgreSQL.Expression

Methods

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

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

PGAvg PGint8 PGnumeric

Defined in Squeal.PostgreSQL.Expression

Methods

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

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

PGAvg PGnumeric PGnumeric

Defined in Squeal.PostgreSQL.Expression

Methods

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

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

PGAvg PGfloat4 PGfloat8

Defined in Squeal.PostgreSQL.Expression

Methods

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

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

PGAvg PGfloat8 PGfloat8

Defined in Squeal.PostgreSQL.Expression

Methods

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

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

PGAvg PGinterval PGinterval

Defined in Squeal.PostgreSQL.Expression

Methods

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

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

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

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGint2

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGint4

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGint8

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGnumeric

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGfloat4

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGfloat8

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGtext

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGbytea

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGtimestamp

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGtimestamptz

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGdate

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGtime

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGtimetz

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGinterval

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGuuid

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGinet

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGjson

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid PGjsonb

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid (PGchar n)

Defined in Squeal.PostgreSQL.Schema

Methods

oid :: Word32

HasOid (PGvarchar n)

Defined in Squeal.PostgreSQL.Schema

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

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

Defined in Squeal.PostgreSQL.Expression

Methods

(!) :: Alias relation -> Alias column -> NP (Aliased (Expression schema relations (Grouped bys) params)) ((column ::: ty) ': [])

(Has relation relations columns, Has column columns ty, GroupedBy relation column bys) => IsQualified relation column (Aliased (Expression schema relations (Grouped bys) params) (column ::: ty))

Defined in Squeal.PostgreSQL.Expression

Methods

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

(Has relation relations columns, Has column columns ty) => IsQualified relation column (NP (Aliased (Expression schema relations Ungrouped params)) ((column ::: ty) ': ([] :: [(Symbol, NullityType)])))

Defined in Squeal.PostgreSQL.Expression

Methods

(!) :: Alias relation -> Alias column -> NP (Aliased (Expression schema relations Ungrouped params)) ((column ::: ty) ': [])

(Has relation relations columns, Has column columns ty) => IsQualified relation column (Aliased (Expression schema relations Ungrouped params) (column ::: ty))

Defined in Squeal.PostgreSQL.Expression

Methods

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

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

Defined in Squeal.PostgreSQL.Expression

Methods

parameter :: TypeExpression schema (PGTypeOf ty) -> Expression schema relations grouping (ty' ': params) ty

HasParameter 1 schema (ty1 ': tys) ty1

Defined in Squeal.PostgreSQL.Expression

Methods

parameter :: TypeExpression schema (PGTypeOf ty1) -> Expression schema relations grouping (ty1 ': tys) ty1

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

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: NP (Aliased (Expression schema relations (Grouped bys) params)) ((column ::: ty) ': [])

(HasUnique relation relations columns, Has column columns ty, GroupedBy relation column bys) => IsLabel column (Aliased (Expression schema relations (Grouped bys) params) (column ::: ty))

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: Aliased (Expression schema relations (Grouped bys) params) (column ::: ty)

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

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: NP (Aliased (Expression schema relations Ungrouped params)) ((column ::: ty) ': [])

(HasUnique relation relations columns, Has column columns ty) => IsLabel column (Aliased (Expression schema relations Ungrouped params) (column ::: ty))

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: Aliased (Expression schema relations Ungrouped params) (column ::: ty)

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

Defined in Squeal.PostgreSQL.Binary

Methods

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

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

Defined in Squeal.PostgreSQL.Binary

Methods

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

ty0 ~ ty1 => SamePGType (alias0 ::: (def0 :=> nullity0 ty0)) (alias1 ::: (def1 :=> nullity1 ty1))

Defined in Squeal.PostgreSQL.Schema

AddColumn (Def :=> ty)

Defined in Squeal.PostgreSQL.Definition

Methods

addColumn :: (KnownSymbol column, Has tab schema (Table table0), table0 ~ (constraints :=> columns), table1 ~ (constraints :=> Create column (Def :=> ty) columns)) => Alias column -> ColumnTypeExpression schema (Def :=> ty) -> AlterTable tab table1 schema

AddColumn (NoDef :=> Null ty)

Defined in Squeal.PostgreSQL.Definition

Methods

addColumn :: (KnownSymbol column, Has tab schema (Table table0), table0 ~ (constraints :=> columns), table1 ~ (constraints :=> Create column (NoDef :=> Null ty) columns)) => Alias column -> ColumnTypeExpression schema (NoDef :=> Null ty) -> AlterTable tab table1 schema

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

Tables

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

Schema

data SchemumType

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

Constructors

Table TableType

View RelationType

Typedef PGType

Instances

Category Definition

Defined in Squeal.PostgreSQL.Definition

Methods

id :: Definition a a

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

type SchemaType = [(Symbol, SchemumType)]

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

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

ty0 ~ ty1 => SamePGType (alias0 ::: (def0 :=> nullity0 ty0)) (alias1 ::: (def1 :=> nullity1 ty1))

Defined in Squeal.PostgreSQL.Schema

AddColumn (Def :=> ty)

Defined in Squeal.PostgreSQL.Definition

Methods

addColumn :: (KnownSymbol column, Has tab schema (Table table0), table0 ~ (constraints :=> columns), table1 ~ (constraints :=> Create column (Def :=> ty) columns)) => Alias column -> ColumnTypeExpression schema (Def :=> ty) -> AlterTable tab table1 schema

AddColumn (NoDef :=> Null ty)

Defined in Squeal.PostgreSQL.Definition

Methods

addColumn :: (KnownSymbol column, Has tab schema (Table table0), table0 ~ (constraints :=> columns), table1 ~ (constraints :=> Create column (NoDef :=> Null ty) columns)) => Alias column -> ColumnTypeExpression schema (NoDef :=> Null ty) -> AlterTable tab table1 schema

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]

type TableConstraints = [(Symbol, TableConstraint)]

A TableConstraints is a row of TableConstraints.

type family NilTableConstraints :: TableConstraints where ...

A monokinded empty TableConstraints.

Equations

NilTableConstraints = '[]

type family Uniquely (key :: [Symbol]) (constraints :: TableConstraints) :: Constraint where ...

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

Equations

Uniquely key ((uq ::: Unique key) ': constraints) = ()

Uniquely key ((pk ::: PrimaryKey key) ': constraints) = ()

Uniquely key (_ ': constraints) = Uniquely key constraints

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.

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)

Defined in Squeal.PostgreSQL.Schema

Methods

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

alias1 ~ alias2 => IsLabel alias1 (Alias alias2)

Defined in Squeal.PostgreSQL.Schema

Methods

fromLabel :: Alias alias2

(alias0 ~ alias1, alias0 ~ alias2, KnownSymbol alias2) => IsLabel alias0 (Aliased Alias (alias1 ::: alias2))

Defined in Squeal.PostgreSQL.Schema

Methods

fromLabel :: Aliased Alias (alias1 ::: alias2)

aliases ~ (alias ': ([] :: [Symbol])) => IsLabel alias (NP Alias aliases)

Defined in Squeal.PostgreSQL.Schema

Methods

fromLabel :: NP Alias aliases

Eq (Alias alias)

Defined in Squeal.PostgreSQL.Schema

Methods

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

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

Ord (Alias alias)

Defined in Squeal.PostgreSQL.Schema

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)

Defined in Squeal.PostgreSQL.Schema

Methods

showsPrec :: Int -> Alias alias -> ShowS

show :: Alias alias -> String

showList :: [Alias alias] -> ShowS

Generic (Alias alias)

Defined in Squeal.PostgreSQL.Schema

Associated Types

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

Methods

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

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

NFData (Alias alias)

Defined in Squeal.PostgreSQL.Schema

Methods

rnf :: Alias alias -> ()

KnownSymbol alias => RenderSQL (Alias alias)

Defined in Squeal.PostgreSQL.Schema

Methods

renderSQL :: Alias alias -> ByteString

type Rep (Alias alias)

Defined in Squeal.PostgreSQL.Schema

type Rep (Alias alias) = D1 (MetaData "Alias" "Squeal.PostgreSQL.Schema" "squeal-postgresql-0.3.2.0-C1DUTRQBZ7xFTzLk0tObU0" False) (C1 (MetaCons "Alias" PrefixI False) (U1 :: * -> *))

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

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

renderAliases :: All KnownSymbol aliases => NP Alias aliases -> [ByteString]

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

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

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

Defined in Squeal.PostgreSQL.Expression

Methods

(!) :: Alias relation -> Alias column -> NP (Aliased (Expression schema relations (Grouped bys) params)) ((column ::: ty) ': [])

(Has relation relations columns, Has column columns ty, GroupedBy relation column bys) => IsQualified relation column (Aliased (Expression schema relations (Grouped bys) params) (column ::: ty))

Defined in Squeal.PostgreSQL.Expression

Methods

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

(Has relation relations columns, Has column columns ty) => IsQualified relation column (NP (Aliased (Expression schema relations Ungrouped params)) ((column ::: ty) ': ([] :: [(Symbol, NullityType)])))

Defined in Squeal.PostgreSQL.Expression

Methods

(!) :: Alias relation -> Alias column -> NP (Aliased (Expression schema relations Ungrouped params)) ((column ::: ty) ': [])

(Has relation relations columns, Has column columns ty) => IsQualified relation column (Aliased (Expression schema relations Ungrouped params) (column ::: ty))

Defined in Squeal.PostgreSQL.Expression

Methods

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

(KnownSymbol alias, tys ~ ((alias ::: ty) ': ([] :: [(Symbol, k)]))) => Aliasable alias (expression ty) (NP (Aliased expression) tys)

Defined in Squeal.PostgreSQL.Schema

Methods

as :: expression ty -> Alias alias -> NP (Aliased expression) tys

(alias ~ alias1, KnownSymbol alias) => Aliasable alias (expression ty) (Aliased expression (alias1 ::: ty))

Defined in Squeal.PostgreSQL.Schema

Methods

as :: expression ty -> Alias alias -> Aliased expression (alias1 ::: ty)

(alias0 ~ alias1, alias0 ~ alias2, KnownSymbol alias2) => IsLabel alias0 (Aliased Alias (alias1 ::: alias2))

Defined in Squeal.PostgreSQL.Schema

Methods

fromLabel :: Aliased Alias (alias1 ::: alias2)

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

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: NP (Aliased (Expression schema relations (Grouped bys) params)) ((column ::: ty) ': [])

(HasUnique relation relations columns, Has column columns ty, GroupedBy relation column bys) => IsLabel column (Aliased (Expression schema relations (Grouped bys) params) (column ::: ty))

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: Aliased (Expression schema relations (Grouped bys) params) (column ::: ty)

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

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: NP (Aliased (Expression schema relations Ungrouped params)) ((column ::: ty) ': [])

(HasUnique relation relations columns, Has column columns ty) => IsLabel column (Aliased (Expression schema relations Ungrouped params) (column ::: ty))

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: Aliased (Expression schema relations Ungrouped params) (column ::: ty)

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

Defined in Squeal.PostgreSQL.Schema

Methods

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

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

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

Defined in Squeal.PostgreSQL.Schema

Methods

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

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

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

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

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

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

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

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

Defined in Squeal.PostgreSQL.Schema

Methods

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

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

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

class KnownSymbol alias => Aliasable alias expression aliased | aliased -> expression, aliased -> alias where

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

Minimal complete definition

as

Methods

as :: expression -> Alias alias -> aliased

Instances

(KnownSymbol alias, tys ~ ((alias ::: ty) ': ([] :: [(Symbol, k)]))) => Aliasable alias (expression ty) (NP (Aliased expression) tys)

Defined in Squeal.PostgreSQL.Schema

Methods

as :: expression ty -> Alias alias -> NP (Aliased expression) tys

(alias ~ alias1, KnownSymbol alias) => Aliasable alias (expression ty) (Aliased expression (alias1 ::: ty))

Defined in Squeal.PostgreSQL.Schema

Methods

as :: expression ty -> Alias alias -> Aliased expression (alias1 ::: ty)

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 (SListI (ZipAs ns xs), All KnownSymbol ns) => ZipAliased ns xs where

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.

Minimal complete definition

zipAs

Associated Types

type ZipAs (ns :: [Symbol]) (xs :: [k]) = (zs :: [(Symbol, k)]) | zs -> ns xs

Methods

zipAs :: NP Alias ns -> NP expr xs -> NP (Aliased expr) (ZipAs ns xs)

Instances

ZipAliased ([] :: [Symbol]) ([] :: [k])

Defined in Squeal.PostgreSQL.Schema

Associated Types

type ZipAs [] [] = (zs :: [(Symbol, k)])

Methods

zipAs :: NP Alias [] -> NP expr [] -> NP (Aliased expr) (ZipAs [] [])

(KnownSymbol n, ZipAliased ns xs) => ZipAliased (n ': ns) (x ': xs :: [k])

Defined in Squeal.PostgreSQL.Schema

Associated Types

type ZipAs (n ': ns) (x ': xs) = (zs :: [(Symbol, k)])

Methods

zipAs :: NP Alias (n ': ns) -> NP expr (x ': xs) -> NP (Aliased expr) (ZipAs (n ': ns) (x ': xs))

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, inferring field from alias and fields.

Instances

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

Defined in Squeal.PostgreSQL.Schema

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

Defined in Squeal.PostgreSQL.Schema

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 All KnownSymbol aliases => HasAll (aliases :: [Symbol]) (fields :: [(Symbol, kind)]) (subfields :: [(Symbol, kind)]) | aliases fields -> subfields

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

Instances

HasAll ([] :: [Symbol]) (fields :: [(Symbol, kind)]) ([] :: [(Symbol, kind)])

Defined in Squeal.PostgreSQL.Schema

(Has alias fields field, HasAll aliases fields subfields) => HasAll (alias ': aliases) (fields :: [(Symbol, k)]) ((alias ::: field) ': subfields :: [(Symbol, k)])

Defined in Squeal.PostgreSQL.Schema

class IsLabel (x :: Symbol) a where

Minimal complete definition

fromLabel

Methods

fromLabel :: a

Instances

alias1 ~ alias2 => IsLabel alias1 (Alias alias2)

Defined in Squeal.PostgreSQL.Schema

Methods

fromLabel :: Alias alias2

Has alias schema (Typedef ty) => IsLabel alias (TypeExpression schema ty)

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: TypeExpression schema ty

Has field fields ty => IsLabel field (Expression schema relation grouping params (nullity (PGcomposite fields)) -> Expression schema relation grouping params (Null ty))

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: Expression schema relation grouping params (nullity (PGcomposite fields)) -> Expression schema relation grouping params (Null ty)

(HasUnique rel rels cols, Has col cols ty, by ~ (,) rel col) => IsLabel col (By rels by)

Defined in Squeal.PostgreSQL.Query

Methods

fromLabel :: By rels by

(alias0 ~ alias1, alias0 ~ alias2, KnownSymbol alias2) => IsLabel alias0 (Aliased Alias (alias1 ::: alias2))

Defined in Squeal.PostgreSQL.Schema

Methods

fromLabel :: Aliased Alias (alias1 ::: alias2)

aliases ~ (alias ': ([] :: [Symbol])) => IsLabel alias (NP Alias aliases)

Defined in Squeal.PostgreSQL.Schema

Methods

fromLabel :: NP Alias aliases

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

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: NP (Aliased (Expression schema relations (Grouped bys) params)) ((column ::: ty) ': [])

(HasUnique relation relations columns, Has column columns ty, GroupedBy relation column bys) => IsLabel column (Aliased (Expression schema relations (Grouped bys) params) (column ::: ty))

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: Aliased (Expression schema relations (Grouped bys) params) (column ::: ty)

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

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: NP (Aliased (Expression schema relations Ungrouped params)) ((column ::: ty) ': [])

(HasUnique relation relations columns, Has column columns ty) => IsLabel column (Aliased (Expression schema relations Ungrouped params) (column ::: ty))

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: Aliased (Expression schema relations Ungrouped params) (column ::: ty)

(HasUnique rel rels cols, Has col cols ty, bys ~ ((,) rel col ': ([] :: [(Symbol, Symbol)]))) => IsLabel col (NP (By rels) bys)

Defined in Squeal.PostgreSQL.Query

Methods

fromLabel :: NP (By rels) bys

(HasUnique relation relations columns, Has column columns ty, GroupedBy relation column bys) => IsLabel column (Expression schema relations (Grouped bys) params ty)

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: Expression schema relations (Grouped bys) params ty

(HasUnique relation relations columns, Has column columns ty) => IsLabel column (Expression schema relations Ungrouped params ty)

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: Expression schema 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)

Defined in Squeal.PostgreSQL.Schema

Methods

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

(Has rel rels cols, Has col cols ty, by ~ (,) rel col) => IsQualified rel col (By rels by)

Defined in Squeal.PostgreSQL.Query

Methods

(!) :: Alias rel -> Alias col -> By rels by

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

Defined in Squeal.PostgreSQL.Expression

Methods

(!) :: Alias relation -> Alias column -> NP (Aliased (Expression schema relations (Grouped bys) params)) ((column ::: ty) ': [])

(Has relation relations columns, Has column columns ty, GroupedBy relation column bys) => IsQualified relation column (Aliased (Expression schema relations (Grouped bys) params) (column ::: ty))

Defined in Squeal.PostgreSQL.Expression

Methods

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

(Has relation relations columns, Has column columns ty) => IsQualified relation column (NP (Aliased (Expression schema relations Ungrouped params)) ((column ::: ty) ': ([] :: [(Symbol, NullityType)])))

Defined in Squeal.PostgreSQL.Expression

Methods

(!) :: Alias relation -> Alias column -> NP (Aliased (Expression schema relations Ungrouped params)) ((column ::: ty) ': [])

(Has relation relations columns, Has column columns ty) => IsQualified relation column (Aliased (Expression schema relations Ungrouped params) (column ::: ty))

Defined in Squeal.PostgreSQL.Expression

Methods

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

(Has rel rels cols, Has col cols ty, bys ~ ((,) rel col ': ([] :: [(Symbol, Symbol)]))) => IsQualified rel col (NP (By rels) bys)

Defined in Squeal.PostgreSQL.Query

Methods

(!) :: Alias rel -> Alias col -> NP (By rels) bys

(Has relation relations columns, Has column columns ty, GroupedBy relation column bys) => IsQualified relation column (Expression schema relations (Grouped bys) params ty)

Defined in Squeal.PostgreSQL.Expression

Methods

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

(Has relation relations columns, Has column columns ty) => IsQualified relation column (Expression schema relations Ungrouped params ty)

Defined in Squeal.PostgreSQL.Expression

Methods

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

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

>>> renderAliasString #ohmahgerd
"'ohmahgerd'"

Enumerated Labels

class IsPGlabel (label :: Symbol) expr where

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

Minimal complete definition

label

Methods

label :: expr

Instances

label ~ label1 => IsPGlabel label (PGlabel label1)

Defined in Squeal.PostgreSQL.Schema

Methods

label :: PGlabel label1

labels ~ (label ': ([] :: [Symbol])) => IsPGlabel label (NP PGlabel labels)

Defined in Squeal.PostgreSQL.Schema

Methods

label :: NP PGlabel labels

(KnownSymbol label, In label labels) => IsPGlabel label (Expression schema relations grouping params (nullity (PGenum labels)))

Defined in Squeal.PostgreSQL.Expression

Methods

label :: Expression schema relations grouping params (nullity (PGenum labels))

data PGlabel (label :: Symbol)

A PGlabel unit type with an IsPGlabel instance

Constructors

PGlabel

Instances

label ~ label1 => IsPGlabel label (PGlabel label1)

Defined in Squeal.PostgreSQL.Schema

Methods

label :: PGlabel label1

labels ~ (label ': ([] :: [Symbol])) => IsPGlabel label (NP PGlabel labels)

Defined in Squeal.PostgreSQL.Schema

Methods

label :: NP PGlabel labels

renderLabel :: KnownSymbol label => proxy label -> ByteString

Renders a label

renderLabels :: All KnownSymbol labels => NP PGlabel labels -> [ByteString]

Renders a list of labels

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 relation column ((,) table column ': bys :: [(k, Symbol)])

Defined in Squeal.PostgreSQL.Schema

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

Defined in Squeal.PostgreSQL.Schema

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 With (relations :: RelationsType) (schema :: SchemaType) :: SchemaType where ...

Used in with.

Equations

With '[] schema = schema

With ((alias ::: rel) ': rels) schema = (alias ::: View rel) ': With rels schema

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 x ((alias ::: y) ': xs) = TypeError ((Text "Create: alias " :<>: ShowType alias) :<>: Text "already in use")

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

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

Equations

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

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

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 PGarrayOf name arr ty :: Constraint where ...

Ensure a type is a valid array type with a specific element type.

Equations

PGarrayOf name (PGvararray x) ty = x ~ ty

PGarrayOf name (PGfixarray n x) ty = x ~ ty

PGarrayOf name val ty = TypeError ((((Text name :<>: Text "Unsatisfied PGarrayOf constraint. Expected either: ") :$$: (Text " \8226 " :<>: ErrPGvararrayOf (ShowType ty))) :$$: (Text " \8226 " :<>: ErrPGfixarrayOf (ShowType ty))) :$$: (Text "But got: " :<>: ShowType val))

type family PGarray name arr :: Constraint where ...

Ensure a type is a valid array type.

Equations

PGarray name (PGvararray x) = ()

PGarray name (PGfixarray n x) = ()

PGarray name val = TypeError ((((Text name :<>: Text ": Unsatisfied PGarray constraint. Expected either: ") :$$: (Text " \8226 " :<>: ErrPGvararrayOf (Placeholder PGType))) :$$: (Text " \8226 " :<>: ErrPGfixarrayOf (Placeholder PGType))) :$$: (Text "But got: " :<>: ShowType val))

type PGtextArray name arr = PGarrayOf name arr PGtext

Ensure a type is a valid array type whose elements are text.

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)

class SamePGType (ty0 :: (Symbol, ColumnType)) (ty1 :: (Symbol, ColumnType))

Equality constraint on the underlying PGType of two columns.

Instances

ty0 ~ ty1 => SamePGType (alias0 ::: (def0 :=> nullity0 ty0)) (alias1 ::: (def1 :=> nullity1 ty1))

Defined in Squeal.PostgreSQL.Schema

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 TableToColumns (table :: TableType) :: ColumnsType where ...

TableToColumns removes table constraints.

Equations

TableToColumns (constraints :=> columns) = columns

type family TableToRelation (table :: TableType) :: RelationType where ...

Convert a table to a relation.

Equations

TableToRelation tab = ColumnsToRelation (TableToColumns tab)

type family RelationToRowType (tables :: RelationType) :: [(Symbol, PGType)] where ...

RelationToRowType drops the nullity constraints of its argument relations.

Equations

RelationToRowType (nullity x ': xs) = x ': RelationToRowType xs

RelationToRowType '[] = '[]

type family RelationToNullityTypes (rel :: RelationType) :: [NullityType] where ...

RelationToNullityTypes drops the column constraints.

Equations

RelationToNullityTypes ('(k, x) ': xs) = x ': RelationToNullityTypes xs

RelationToNullityTypes '[] = '[]

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)

JSON support

type PGjson_ json = json `In` '[PGjson, PGjsonb]

Is a type a valid JSON type?

type PGjsonKey key = key `In` '[PGint2, PGint4, PGtext]

Is a type a valid JSON key?

Embedding

type family PG (hask :: Type) :: PGType where ...

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

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

Equations

PG Bool = PGbool

PG Int16 = PGint2

PG Int32 = PGint4

PG Int64 = PGint8

PG Word16 = PGint2

PG Word32 = PGint4

PG Word64 = PGint8

PG Scientific = PGnumeric

PG Float = PGfloat4

PG Double = PGfloat8

PG Char = PGchar 1

PG Text = PGtext

PG Text = PGtext

PG ByteString = PGbytea

PG ByteString = PGbytea

PG LocalTime = PGtimestamp

PG UTCTime = PGtimestamptz

PG Day = PGdate

PG TimeOfDay = PGtime

PG (TimeOfDay, TimeZone) = PGtimetz

PG DiffTime = PGinterval

PG UUID = PGuuid

PG (NetAddr IP) = PGinet

PG Value = PGjson

PG ty = TypeError (Text "There is no Postgres basic type for " :<>: ShowType ty)

type family EnumFrom (hask :: Type) :: PGType where ...

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"]

Equations

EnumFrom hask = PGenum (LabelsFrom hask)

type family LabelsFrom (hask :: Type) :: [ConstructorName] where ...

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"]

Equations

LabelsFrom hask = ConstructorNamesOf (ConstructorsOf (DatatypeInfoOf hask))

type family CompositeFrom (hask :: Type) :: PGType where ...

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)]

Equations

CompositeFrom hask = PGcomposite (ZipAs (FieldNamesFrom hask) (FieldTypesFrom hask))

type family FieldNamesFrom (hask :: Type) :: [FieldName] where ...

>>> 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"]

Equations

FieldNamesFrom hask = FieldNamesOf (FieldsOf (DatatypeInfoOf hask))

type family FieldTypesFrom (hask :: Type) :: [PGType] where ...

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

Equations

FieldTypesFrom hask = FieldTypesOf (RecordCodeOf hask (Code hask))

type family ConstructorsOf (datatype :: DatatypeInfo) :: [ConstructorInfo] where ...

Calculates constructors of a datatype.

Equations

ConstructorsOf (ADT _module _datatype constructors) = constructors

ConstructorsOf (Newtype _module _datatype constructor) = '[constructor]

type family ConstructorNameOf (constructors :: ConstructorInfo) :: ConstructorName where ...

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

Equations

ConstructorNameOf (Constructor name) = name

ConstructorNameOf (Infix name _assoc _fix) = TypeError (Text "ConstructorNameOf error: non-nullary constructor " :<>: Text name)

ConstructorNameOf (Record name _fields) = TypeError (Text "ConstructorNameOf error: non-nullary constructor " :<>: Text name)

type family ConstructorNamesOf (constructors :: [ConstructorInfo]) :: [ConstructorName] where ...

Calculate the names of nullary constructors.

Equations

ConstructorNamesOf '[] = '[]

ConstructorNamesOf (constructor ': constructors) = ConstructorNameOf constructor ': ConstructorNamesOf constructors

type family FieldsOf (datatype :: DatatypeInfo) :: [FieldInfo] where ...

Calculate the fields of a datatype.

Equations

FieldsOf (ADT _module _datatype '[Record _name fields]) = fields

FieldsOf (Newtype _module _datatype (Record _name fields)) = fields

type family FieldNameOf (field :: FieldInfo) :: FieldName where ...

Calculate the name of a field.

Equations

FieldNameOf (FieldInfo name) = name

type family FieldNamesOf (fields :: [FieldInfo]) :: [FieldName] where ...

Calculate the names of fields.

Equations

FieldNamesOf '[] = '[]

FieldNamesOf (field ': fields) = FieldNameOf field ': FieldNamesOf fields

type family FieldTypeOf (maybe :: Type) where ...

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

Equations

FieldTypeOf (Maybe hask) = PG hask

FieldTypeOf ty = TypeError (Text "FieldTypeOf error: non-Maybe type " :<>: ShowType ty)

type family FieldTypesOf (fields :: [Type]) where ...

Calculate the types of fields.

Equations

FieldTypesOf '[] = '[]

FieldTypesOf (field ': fields) = FieldTypeOf field ': FieldTypesOf fields

type family RecordCodeOf (hask :: Type) (code :: [[Type]]) :: [Type] where ...

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

Equations

RecordCodeOf _hask '[tys] = tys

RecordCodeOf hask _tys = TypeError (Text "RecordCodeOf error: non-Record type " :<>: ShowType hask)

class MapMaybes xs where

MapMaybes is used in the binary instances of composite types.

Minimal complete definition

maybes, unMaybes

Associated Types

type Maybes (xs :: [Type]) = (mxs :: [Type]) | mxs -> xs

Methods

maybes :: NP Maybe xs -> NP I (Maybes xs)

unMaybes :: NP I (Maybes xs) -> NP Maybe xs

Instances

MapMaybes ([] :: [Type])

Defined in Squeal.PostgreSQL.Schema

Associated Types

type Maybes [] = (mxs :: [Type])

Methods

maybes :: NP Maybe [] -> NP I (Maybes [])

unMaybes :: NP I (Maybes []) -> NP Maybe []

MapMaybes xs => MapMaybes (x ': xs)

Defined in Squeal.PostgreSQL.Schema

Associated Types

type Maybes (x ': xs) = (mxs :: [Type])

Methods

maybes :: NP Maybe (x ': xs) -> NP I (Maybes (x ': xs))

unMaybes :: NP I (Maybes (x ': xs)) -> NP Maybe (x ': xs)

type family Nulls tys where ...

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

Equations

Nulls '[] = '[]

Nulls ((field ::: ty) ': tys) = (field ::: Null ty) ': Nulls tys