{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}
{-# LANGUAGE
AllowAmbiguousTypes
, DataKinds
, DeriveGeneric
, DeriveDataTypeable
, FlexibleContexts
, FlexibleInstances
, FunctionalDependencies
, GADTs
, GeneralizedNewtypeDeriving
, LambdaCase
, MagicHash
, OverloadedStrings
, PolyKinds
, RankNTypes
, ScopedTypeVariables
, StandaloneDeriving
, TypeApplications
, TypeFamilies
, TypeInType
, TypeOperators
, UndecidableInstances
#-}
module Squeal.PostgreSQL.Expression
(
Expression (UnsafeExpression, renderExpression)
, HasParameter (param)
, null_
, unNull
, coalesce
, fromNull
, isNull
, isn'tNull
, matchNull
, nullIf
, array
, unsafeBinaryOp
, unsafeUnaryOp
, unsafeFunction
, atan2_
, cast
, quot_
, rem_
, trunc
, round_
, ceiling_
, greatest
, least
, Condition
, true
, false
, not_
, (.&&)
, (.||)
, caseWhenThenElse
, ifThenElse
, (.==)
, (./=)
, (.>=)
, (.<)
, (.<=)
, (.>)
, currentDate
, currentTime
, currentTimestamp
, localTime
, localTimestamp
, lower
, upper
, charLength
, like
, unsafeAggregate, unsafeAggregateDistinct
, sum_, sumDistinct
, PGAvg (avg, avgDistinct)
, bitAnd, bitOr, boolAnd, boolOr
, bitAndDistinct, bitOrDistinct, boolAndDistinct, boolOrDistinct
, countStar
, count, countDistinct
, every, everyDistinct
, max_, maxDistinct, min_, minDistinct
, Table (UnsafeTable, renderTable)
, TypeExpression (UnsafeTypeExpression, renderTypeExpression)
, PGTyped (pgtype)
, bool
, int2
, smallint
, int4
, int
, integer
, int8
, bigint
, numeric
, float4
, real
, float8
, doublePrecision
, serial2
, smallserial
, serial4
, serial
, serial8
, bigserial
, text
, char
, character
, varchar
, characterVarying
, bytea
, timestamp
, timestampWithTimeZone
, date
, time
, timeWithTimeZone
, interval
, uuid
, inet
, json
, jsonb
, vararray
, fixarray
, notNull
, default_
, (&)
, NP ((:*), Nil)
) where
import Control.Category
import Control.DeepSeq
import Data.ByteString (ByteString)
import Data.Function ((&))
import Data.Monoid hiding (All)
import Data.Ratio
import Data.String
import Generics.SOP hiding (from)
import GHC.OverloadedLabels
import GHC.TypeLits
import Prelude hiding (id, (.))
import qualified GHC.Generics as GHC
import Squeal.PostgreSQL.Render
import Squeal.PostgreSQL.Schema
newtype Expression
(relations :: RelationsType)
(grouping :: Grouping)
(params :: [NullityType])
(ty :: NullityType)
= UnsafeExpression { renderExpression :: ByteString }
deriving (GHC.Generic,Show,Eq,Ord,NFData)
class (PGTyped (PGTypeOf ty), KnownNat n) => HasParameter
(n :: Nat)
(params :: [NullityType])
(ty :: NullityType)
| n params -> ty where
param :: Expression relations grouping params ty
param = UnsafeExpression $ parenthesized $
"$" <> renderNat (Proxy @n) <+> "::"
<+> renderTypeExpression (pgtype @(PGTypeOf ty))
instance {-# OVERLAPPING #-} PGTyped (PGTypeOf ty1)
=> HasParameter 1 (ty1:tys) ty1
instance {-# OVERLAPPABLE #-} (KnownNat n, HasParameter (n-1) params ty)
=> HasParameter n (ty' : params) ty
instance (HasUnique relation relations columns, Has column columns ty)
=> IsLabel column (Expression relations 'Ungrouped params ty) where
fromLabel = UnsafeExpression $ renderAlias (Alias @column)
instance (Has relation relations columns, Has column columns ty)
=> IsQualified relation column (Expression relations 'Ungrouped params ty) where
relation ! column = UnsafeExpression $
renderAlias relation <> "." <> renderAlias column
instance
( HasUnique relation relations columns
, Has column columns ty
, GroupedBy relation column bys
) => IsLabel column
(Expression relations ('Grouped bys) params ty) where
fromLabel = UnsafeExpression $ renderAlias (Alias @column)
instance
( Has relation relations columns
, Has column columns ty
, GroupedBy relation column bys
) => IsQualified relation column
(Expression relations ('Grouped bys) params ty) where
relation ! column = UnsafeExpression $
renderAlias relation <> "." <> renderAlias column
null_ :: Expression relations grouping params ('Null ty)
null_ = UnsafeExpression "NULL"
unNull
:: Expression relations grouping params ('NotNull ty)
-> Expression relations grouping params ('Null ty)
unNull = UnsafeExpression . renderExpression
coalesce
:: [Expression relations grouping params ('Null ty)]
-> Expression relations grouping params ('NotNull ty)
-> Expression relations grouping params ('NotNull ty)
coalesce nullxs notNullx = UnsafeExpression $
"COALESCE" <> parenthesized (commaSeparated
((renderExpression <$> nullxs) <> [renderExpression notNullx]))
fromNull
:: Expression relations grouping params ('NotNull ty)
-> Expression relations grouping params ('Null ty)
-> Expression relations grouping params ('NotNull ty)
fromNull notNullx nullx = coalesce [nullx] notNullx
isNull
:: Expression relations grouping params ('Null ty)
-> Condition relations grouping params
isNull x = UnsafeExpression $ renderExpression x <+> "IS NULL"
isn'tNull
:: Expression relations grouping params ('Null ty)
-> Condition relations grouping params
isn'tNull x = UnsafeExpression $ renderExpression x <+> "IS NOT NULL"
matchNull
:: Expression relations grouping params (nullty)
-> ( Expression relations grouping params ('NotNull ty)
-> Expression relations grouping params (nullty) )
-> Expression relations grouping params ('Null ty)
-> Expression relations grouping params (nullty)
matchNull y f x = ifThenElse (isNull x) y
(f (UnsafeExpression (renderExpression x)))
nullIf
:: Expression relations grouping params ('NotNull ty)
-> Expression relations grouping params ('NotNull ty)
-> Expression relations grouping params ('Null ty)
nullIf x y = UnsafeExpression $ "NULL IF" <+> parenthesized
(renderExpression x <> ", " <> renderExpression y)
array
:: [Expression relations grouping params ('Null ty)]
-> Expression relations grouping params (nullity ('PGvararray ty))
array xs = UnsafeExpression $
"ARRAY[" <> commaSeparated (renderExpression <$> xs) <> "]"
instance Monoid
(Expression relations grouping params (nullity ('PGvararray ty))) where
mempty = array []
mappend = unsafeBinaryOp "||"
greatest
:: Expression relations grouping params (nullty)
-> [Expression relations grouping params (nullty)]
-> Expression relations grouping params (nullty)
greatest x xs = UnsafeExpression $ "GREATEST("
<> commaSeparated (renderExpression <$> (x:xs)) <> ")"
least
:: Expression relations grouping params (nullty)
-> [Expression relations grouping params (nullty)]
-> Expression relations grouping params (nullty)
least x xs = UnsafeExpression $ "LEAST("
<> commaSeparated (renderExpression <$> (x:xs)) <> ")"
unsafeBinaryOp
:: ByteString
-> Expression relations grouping params (ty0)
-> Expression relations grouping params (ty1)
-> Expression relations grouping params (ty2)
unsafeBinaryOp op x y = UnsafeExpression $ parenthesized $
renderExpression x <+> op <+> renderExpression y
unsafeUnaryOp
:: ByteString
-> Expression relations grouping params (ty0)
-> Expression relations grouping params (ty1)
unsafeUnaryOp op x = UnsafeExpression $ parenthesized $
op <+> renderExpression x
unsafeFunction
:: ByteString
-> Expression relations grouping params (xty)
-> Expression relations grouping params (yty)
unsafeFunction fun x = UnsafeExpression $
fun <> parenthesized (renderExpression x)
instance PGNum ty
=> Num (Expression relations grouping params (nullity ty)) where
(+) = unsafeBinaryOp "+"
(-) = unsafeBinaryOp "-"
(*) = unsafeBinaryOp "*"
abs = unsafeFunction "abs"
signum = unsafeFunction "sign"
fromInteger
= UnsafeExpression
. fromString
. show
instance (PGNum ty, PGFloating ty) => Fractional
(Expression relations grouping params (nullity ty)) where
(/) = unsafeBinaryOp "/"
fromRational x = fromInteger (numerator x) / fromInteger (denominator x)
instance (PGNum ty, PGFloating ty) => Floating
(Expression relations grouping params (nullity ty)) where
pi = UnsafeExpression "pi()"
exp = unsafeFunction "exp"
log = unsafeFunction "ln"
sqrt = unsafeFunction "sqrt"
b ** x = UnsafeExpression $
"power(" <> renderExpression b <> ", " <> renderExpression x <> ")"
logBase b y = log y / log b
sin = unsafeFunction "sin"
cos = unsafeFunction "cos"
tan = unsafeFunction "tan"
asin = unsafeFunction "asin"
acos = unsafeFunction "acos"
atan = unsafeFunction "atan"
sinh x = (exp x - exp (-x)) / 2
cosh x = (exp x + exp (-x)) / 2
tanh x = sinh x / cosh x
asinh x = log (x + sqrt (x*x + 1))
acosh x = log (x + sqrt (x*x - 1))
atanh x = log ((1 + x) / (1 - x)) / 2
atan2_
:: PGFloating float
=> Expression relations grouping params (nullity float)
-> Expression relations grouping params (nullity float)
-> Expression relations grouping params (nullity float)
atan2_ y x = UnsafeExpression $
"atan2(" <> renderExpression y <> ", " <> renderExpression x <> ")"
cast
:: TypeExpression ('NoDef :=> 'Null ty1)
-> Expression relations grouping params (nullity ty0)
-> Expression relations grouping params (nullity ty1)
cast ty x = UnsafeExpression $ parenthesized $
renderExpression x <+> "::" <+> renderTypeExpression ty
quot_
:: PGIntegral int
=> Expression relations grouping params (nullity int)
-> Expression relations grouping params (nullity int)
-> Expression relations grouping params (nullity int)
quot_ = unsafeBinaryOp "/"
rem_
:: PGIntegral int
=> Expression relations grouping params (nullity int)
-> Expression relations grouping params (nullity int)
-> Expression relations grouping params (nullity int)
rem_ = unsafeBinaryOp "%"
trunc
:: PGFloating frac
=> Expression relations grouping params (nullity frac)
-> Expression relations grouping params (nullity frac)
trunc = unsafeFunction "trunc"
round_
:: PGFloating frac
=> Expression relations grouping params (nullity frac)
-> Expression relations grouping params (nullity frac)
round_ = unsafeFunction "round"
ceiling_
:: PGFloating frac
=> Expression relations grouping params (nullity frac)
-> Expression relations grouping params (nullity frac)
ceiling_ = unsafeFunction "ceiling"
type Condition relations grouping params =
Expression relations grouping params ('NotNull 'PGbool)
true :: Condition relations grouping params
true = UnsafeExpression "TRUE"
false :: Condition relations grouping params
false = UnsafeExpression "FALSE"
not_
:: Condition relations grouping params
-> Condition relations grouping params
not_ = unsafeUnaryOp "NOT"
(.&&)
:: Condition relations grouping params
-> Condition relations grouping params
-> Condition relations grouping params
(.&&) = unsafeBinaryOp "AND"
(.||)
:: Condition relations grouping params
-> Condition relations grouping params
-> Condition relations grouping params
(.||) = unsafeBinaryOp "OR"
caseWhenThenElse
:: [ ( Condition relations grouping params
, Expression relations grouping params (ty)
) ]
-> Expression relations grouping params (ty)
-> Expression relations grouping params (ty)
caseWhenThenElse whenThens else_ = UnsafeExpression $ mconcat
[ "CASE"
, mconcat
[ mconcat
[ " WHEN ", renderExpression when_
, " THEN ", renderExpression then_
]
| (when_,then_) <- whenThens
]
, " ELSE ", renderExpression else_
, " END"
]
ifThenElse
:: Condition relations grouping params
-> Expression relations grouping params (ty)
-> Expression relations grouping params (ty)
-> Expression relations grouping params (ty)
ifThenElse if_ then_ else_ = caseWhenThenElse [(if_,then_)] else_
(.==)
:: Expression relations grouping params (nullity ty)
-> Expression relations grouping params (nullity ty)
-> Expression relations grouping params (nullity 'PGbool)
(.==) = unsafeBinaryOp "="
infix 4 .==
(./=)
:: Expression relations grouping params (nullity ty)
-> Expression relations grouping params (nullity ty)
-> Expression relations grouping params (nullity 'PGbool)
(./=) = unsafeBinaryOp "<>"
infix 4 ./=
(.>=)
:: Expression relations grouping params (nullity ty)
-> Expression relations grouping params (nullity ty)
-> Expression relations grouping params (nullity 'PGbool)
(.>=) = unsafeBinaryOp ">="
infix 4 .>=
(.<)
:: Expression relations grouping params (nullity ty)
-> Expression relations grouping params (nullity ty)
-> Expression relations grouping params (nullity 'PGbool)
(.<) = unsafeBinaryOp "<"
infix 4 .<
(.<=)
:: Expression relations grouping params (nullity ty)
-> Expression relations grouping params (nullity ty)
-> Expression relations grouping params (nullity 'PGbool)
(.<=) = unsafeBinaryOp "<="
infix 4 .<=
(.>)
:: Expression relations grouping params (nullity ty)
-> Expression relations grouping params (nullity ty)
-> Expression relations grouping params (nullity 'PGbool)
(.>) = unsafeBinaryOp ">"
infix 4 .>
currentDate
:: Expression relations grouping params (nullity 'PGdate)
currentDate = UnsafeExpression "CURRENT_DATE"
currentTime
:: Expression relations grouping params (nullity 'PGtimetz)
currentTime = UnsafeExpression "CURRENT_TIME"
currentTimestamp
:: Expression relations grouping params (nullity 'PGtimestamptz)
currentTimestamp = UnsafeExpression "CURRENT_TIMESTAMP"
localTime
:: Expression relations grouping params (nullity 'PGtime)
localTime = UnsafeExpression "LOCALTIME"
localTimestamp
:: Expression relations grouping params (nullity 'PGtimestamp)
localTimestamp = UnsafeExpression "LOCALTIMESTAMP"
instance IsString
(Expression relations grouping params (nullity 'PGtext)) where
fromString str = UnsafeExpression $
"E\'" <> fromString (escape =<< str) <> "\'"
where
escape = \case
'\NUL' -> "\\0"
'\'' -> "''"
'"' -> "\\\""
'\b' -> "\\b"
'\n' -> "\\n"
'\r' -> "\\r"
'\t' -> "\\t"
'\\' -> "\\\\"
c -> [c]
instance Monoid
(Expression relations grouping params (nullity 'PGtext)) where
mempty = fromString ""
mappend = unsafeBinaryOp "||"
lower
:: Expression relations grouping params (nullity 'PGtext)
-> Expression relations grouping params (nullity 'PGtext)
lower = unsafeFunction "lower"
upper
:: Expression relations grouping params (nullity 'PGtext)
-> Expression relations grouping params (nullity 'PGtext)
upper = unsafeFunction "upper"
charLength
:: Expression relations grouping params (nullity 'PGtext)
-> Expression relations grouping params (nullity 'PGint4)
charLength = unsafeFunction "char_length"
like
:: Expression relations grouping params (nullity 'PGtext)
-> Expression relations grouping params (nullity 'PGtext)
-> Expression relations grouping params (nullity 'PGbool)
like = unsafeBinaryOp "LIKE"
unsafeAggregate
:: ByteString
-> Expression relations 'Ungrouped params (xty)
-> Expression relations ('Grouped bys) params (yty)
unsafeAggregate fun x = UnsafeExpression $ mconcat
[fun, "(", renderExpression x, ")"]
unsafeAggregateDistinct
:: ByteString
-> Expression relations 'Ungrouped params (xty)
-> Expression relations ('Grouped bys) params (yty)
unsafeAggregateDistinct fun x = UnsafeExpression $ mconcat
[fun, "(DISTINCT ", renderExpression x, ")"]
sum_
:: PGNum ty
=> Expression relations 'Ungrouped params (nullity ty)
-> Expression relations ('Grouped bys) params (nullity ty)
sum_ = unsafeAggregate "sum"
sumDistinct
:: PGNum ty
=> Expression relations 'Ungrouped params (nullity ty)
-> Expression relations ('Grouped bys) params (nullity ty)
sumDistinct = unsafeAggregateDistinct "sum"
class PGAvg ty avg | ty -> avg where
avg, avgDistinct
:: Expression relations 'Ungrouped params (nullity ty)
-> Expression relations ('Grouped bys) params (nullity avg)
avg = unsafeAggregate "avg"
avgDistinct = unsafeAggregateDistinct "avg"
instance PGAvg 'PGint2 'PGnumeric
instance PGAvg 'PGint4 'PGnumeric
instance PGAvg 'PGint8 'PGnumeric
instance PGAvg 'PGnumeric 'PGnumeric
instance PGAvg 'PGfloat4 'PGfloat8
instance PGAvg 'PGfloat8 'PGfloat8
instance PGAvg 'PGinterval 'PGinterval
bitAnd
:: PGIntegral int
=> Expression relations 'Ungrouped params (nullity int)
-> Expression relations ('Grouped bys) params (nullity int)
bitAnd = unsafeAggregate "bit_and"
bitOr
:: PGIntegral int
=> Expression relations 'Ungrouped params (nullity int)
-> Expression relations ('Grouped bys) params (nullity int)
bitOr = unsafeAggregate "bit_or"
bitAndDistinct
:: PGIntegral int
=> Expression relations 'Ungrouped params (nullity int)
-> Expression relations ('Grouped bys) params (nullity int)
bitAndDistinct = unsafeAggregateDistinct "bit_and"
bitOrDistinct
:: PGIntegral int
=> Expression relations 'Ungrouped params (nullity int)
-> Expression relations ('Grouped bys) params (nullity int)
bitOrDistinct = unsafeAggregateDistinct "bit_or"
boolAnd
:: Expression relations 'Ungrouped params (nullity 'PGbool)
-> Expression relations ('Grouped bys) params (nullity 'PGbool)
boolAnd = unsafeAggregate "bool_and"
boolOr
:: Expression relations 'Ungrouped params (nullity 'PGbool)
-> Expression relations ('Grouped bys) params (nullity 'PGbool)
boolOr = unsafeAggregate "bool_or"
boolAndDistinct
:: Expression relations 'Ungrouped params (nullity 'PGbool)
-> Expression relations ('Grouped bys) params (nullity 'PGbool)
boolAndDistinct = unsafeAggregateDistinct "bool_and"
boolOrDistinct
:: Expression relations 'Ungrouped params (nullity 'PGbool)
-> Expression relations ('Grouped bys) params (nullity 'PGbool)
boolOrDistinct = unsafeAggregateDistinct "bool_or"
countStar
:: Expression relations ('Grouped bys) params ('NotNull 'PGint8)
countStar = UnsafeExpression $ "count(*)"
count
:: Expression relations 'Ungrouped params ty
-> Expression relations ('Grouped bys) params ('NotNull 'PGint8)
count = unsafeAggregate "count"
countDistinct
:: Expression relations 'Ungrouped params ty
-> Expression relations ('Grouped bys) params ('NotNull 'PGint8)
countDistinct = unsafeAggregateDistinct "count"
every
:: Expression relations 'Ungrouped params (nullity 'PGbool)
-> Expression relations ('Grouped bys) params (nullity 'PGbool)
every = unsafeAggregate "every"
everyDistinct
:: Expression relations 'Ungrouped params (nullity 'PGbool)
-> Expression relations ('Grouped bys) params (nullity 'PGbool)
everyDistinct = unsafeAggregateDistinct "every"
max_, min_, maxDistinct, minDistinct
:: Expression relations 'Ungrouped params (nullity ty)
-> Expression relations ('Grouped bys) params (nullity ty)
max_ = unsafeAggregate "max"
min_ = unsafeAggregate "min"
maxDistinct = unsafeAggregateDistinct "max"
minDistinct = unsafeAggregateDistinct "min"
newtype Table
(schema :: TablesType)
(columns :: RelationType)
= UnsafeTable { renderTable :: ByteString }
deriving (GHC.Generic,Show,Eq,Ord,NFData)
instance
( Has alias schema table
, relation ~ ColumnsToRelation (TableToColumns table)
) => IsLabel alias (Table schema relation) where
fromLabel = UnsafeTable $ renderAlias (Alias @alias)
newtype TypeExpression (ty :: ColumnType)
= UnsafeTypeExpression { renderTypeExpression :: ByteString }
deriving (GHC.Generic,Show,Eq,Ord,NFData)
bool :: TypeExpression ('NoDef :=> 'Null 'PGbool)
bool = UnsafeTypeExpression "bool"
int2, smallint :: TypeExpression ('NoDef :=> 'Null 'PGint2)
int2 = UnsafeTypeExpression "int2"
smallint = UnsafeTypeExpression "smallint"
int4, int, integer :: TypeExpression ('NoDef :=> 'Null 'PGint4)
int4 = UnsafeTypeExpression "int4"
int = UnsafeTypeExpression "int"
integer = UnsafeTypeExpression "integer"
int8, bigint :: TypeExpression ('NoDef :=> 'Null 'PGint8)
int8 = UnsafeTypeExpression "int8"
bigint = UnsafeTypeExpression "bigint"
numeric :: TypeExpression ('NoDef :=> 'Null 'PGnumeric)
numeric = UnsafeTypeExpression "numeric"
float4, real :: TypeExpression ('NoDef :=> 'Null 'PGfloat4)
float4 = UnsafeTypeExpression "float4"
real = UnsafeTypeExpression "real"
float8, doublePrecision :: TypeExpression ('NoDef :=> 'Null 'PGfloat8)
float8 = UnsafeTypeExpression "float8"
doublePrecision = UnsafeTypeExpression "double precision"
serial2, smallserial
:: TypeExpression ('Def :=> 'NotNull 'PGint2)
serial2 = UnsafeTypeExpression "serial2"
smallserial = UnsafeTypeExpression "smallserial"
serial4, serial
:: TypeExpression ('Def :=> 'NotNull 'PGint4)
serial4 = UnsafeTypeExpression "serial4"
serial = UnsafeTypeExpression "serial"
serial8, bigserial
:: TypeExpression ('Def :=> 'NotNull 'PGint8)
serial8 = UnsafeTypeExpression "serial8"
bigserial = UnsafeTypeExpression "bigserial"
text :: TypeExpression ('NoDef :=> 'Null 'PGtext)
text = UnsafeTypeExpression "text"
char, character
:: (KnownNat n, 1 <= n)
=> proxy n
-> TypeExpression ('NoDef :=> 'Null ('PGchar n))
char p = UnsafeTypeExpression $ "char(" <> renderNat p <> ")"
character p = UnsafeTypeExpression $ "character(" <> renderNat p <> ")"
varchar, characterVarying
:: (KnownNat n, 1 <= n)
=> proxy n
-> TypeExpression ('NoDef :=> 'Null ('PGvarchar n))
varchar p = UnsafeTypeExpression $ "varchar(" <> renderNat p <> ")"
characterVarying p = UnsafeTypeExpression $
"character varying(" <> renderNat p <> ")"
bytea :: TypeExpression ('NoDef :=> 'Null 'PGbytea)
bytea = UnsafeTypeExpression "bytea"
timestamp :: TypeExpression ('NoDef :=> 'Null 'PGtimestamp)
timestamp = UnsafeTypeExpression "timestamp"
timestampWithTimeZone :: TypeExpression ('NoDef :=> 'Null 'PGtimestamptz)
timestampWithTimeZone = UnsafeTypeExpression "timestamp with time zone"
date :: TypeExpression ('NoDef :=> 'Null 'PGdate)
date = UnsafeTypeExpression "date"
time :: TypeExpression ('NoDef :=> 'Null 'PGtime)
time = UnsafeTypeExpression "time"
timeWithTimeZone :: TypeExpression ('NoDef :=> 'Null 'PGtimetz)
timeWithTimeZone = UnsafeTypeExpression "time with time zone"
interval :: TypeExpression ('NoDef :=> 'Null 'PGinterval)
interval = UnsafeTypeExpression "interval"
uuid :: TypeExpression ('NoDef :=> 'Null 'PGuuid)
uuid = UnsafeTypeExpression "uuid"
inet :: TypeExpression ('NoDef :=> 'Null 'PGinet)
inet = UnsafeTypeExpression "inet"
json :: TypeExpression ('NoDef :=> 'Null 'PGjson)
json = UnsafeTypeExpression "json"
jsonb :: TypeExpression ('NoDef :=> 'Null 'PGjsonb)
jsonb = UnsafeTypeExpression "jsonb"
vararray
:: TypeExpression ('NoDef :=> 'Null pg)
-> TypeExpression ('NoDef :=> 'Null ('PGvararray pg))
vararray ty = UnsafeTypeExpression $ renderTypeExpression ty <> "[]"
fixarray
:: KnownNat n
=> proxy n
-> TypeExpression ('NoDef :=> 'Null pg)
-> TypeExpression ('NoDef :=> 'Null ('PGfixarray n pg))
fixarray p ty = UnsafeTypeExpression $
renderTypeExpression ty <> "[" <> renderNat p <> "]"
notNull
:: TypeExpression (def :=> 'Null ty)
-> TypeExpression (def :=> 'NotNull ty)
notNull ty = UnsafeTypeExpression $ renderTypeExpression ty <+> "NOT NULL"
default_
:: Expression '[] 'Ungrouped '[] ty
-> TypeExpression ('NoDef :=> ty)
-> TypeExpression ('Def :=> ty)
default_ x ty = UnsafeTypeExpression $
renderTypeExpression ty <+> "DEFAULT" <+> renderExpression x
class PGTyped (ty :: PGType) where
pgtype :: TypeExpression ('NoDef :=> 'Null ty)
instance PGTyped 'PGbool where pgtype = bool
instance PGTyped 'PGint2 where pgtype = int2
instance PGTyped 'PGint4 where pgtype = int4
instance PGTyped 'PGint8 where pgtype = int8
instance PGTyped 'PGnumeric where pgtype = numeric
instance PGTyped 'PGfloat4 where pgtype = float4
instance PGTyped 'PGfloat8 where pgtype = float8
instance PGTyped 'PGtext where pgtype = text
instance (KnownNat n, 1 <= n)
=> PGTyped ('PGchar n) where pgtype = char (Proxy @n)
instance (KnownNat n, 1 <= n)
=> PGTyped ('PGvarchar n) where pgtype = varchar (Proxy @n)
instance PGTyped 'PGbytea where pgtype = bytea
instance PGTyped 'PGtimestamp where pgtype = timestamp
instance PGTyped 'PGtimestamptz where pgtype = timestampWithTimeZone
instance PGTyped 'PGdate where pgtype = date
instance PGTyped 'PGtime where pgtype = time
instance PGTyped 'PGtimetz where pgtype = timeWithTimeZone
instance PGTyped 'PGinterval where pgtype = interval
instance PGTyped 'PGuuid where pgtype = uuid
instance PGTyped 'PGjson where pgtype = json
instance PGTyped 'PGjsonb where pgtype = jsonb
instance PGTyped ty => PGTyped ('PGvararray ty) where
pgtype = vararray (pgtype @ty)
instance (KnownNat n, PGTyped ty) => PGTyped ('PGfixarray n ty) where
pgtype = fixarray (Proxy @n) (pgtype @ty)