Squeal.PostgreSQL.Expression

Squeal expressions are the atoms used to build statements.

Expression

newtype Expression (tables :: TablesType) (grouping :: Grouping) (params :: [ColumnType]) (ty :: ColumnType)

Expressions are used in a variety of contexts, such as in the target list of the select command, as new column values in insertInto or update, or in search Conditions in a number of commands.

The expression syntax allows the calculation of values from primitive expression using arithmetic, logical, and other operations.

Constructors

UnsafeExpression

Fields

• renderExpression :: ByteString

Instances

(HasTable table tables columns, HasColumn column columns ty, GroupedBy table column bys) => IsTableColumn table column (Expression tables (Grouped bys) params ty)

Methods

(!) :: Alias table -> Alias column -> Expression tables (Grouped bys) params ty

(HasTable table tables columns, HasColumn column columns ty) => IsTableColumn table column (Expression tables Ungrouped params ty)

Methods

(!) :: Alias table -> Alias column -> Expression tables Ungrouped params ty

(HasUnique ColumnsType table tables columns, HasColumn column columns ty, GroupedBy table column bys) => IsLabel column (Expression tables (Grouped bys) params ty)

Methods

fromLabel :: Expression tables (Grouped bys) params ty

(HasColumn column columns ty, HasUnique ColumnsType table tables columns) => IsLabel column (Expression tables Ungrouped params ty)

Methods

fromLabel :: Expression tables Ungrouped params ty

Eq (Expression tables grouping params ty)

Methods

(==) :: Expression tables grouping params ty -> Expression tables grouping params ty -> Bool

(/=) :: Expression tables grouping params ty -> Expression tables grouping params ty -> Bool

(PGNum ty, PGFloating ty) => Floating (Expression tables grouping params (Required (nullity ty)))

Methods

pi :: Expression tables grouping params (Required (nullity ty))

exp :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

log :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

sqrt :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

(**) :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

logBase :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

sin :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

cos :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

tan :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

asin :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

acos :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

atan :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

sinh :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

cosh :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

tanh :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

asinh :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

acosh :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

atanh :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

log1p :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

expm1 :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

log1pexp :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

log1mexp :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

(PGNum ty, PGFloating ty) => Fractional (Expression tables grouping params (Required (nullity ty)))

Methods

(/) :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

recip :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

fromRational :: Rational -> Expression tables grouping params (Required (nullity ty))

PGNum ty => Num (Expression tables grouping params (Required (nullity ty)))

Methods

(+) :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

(-) :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

(*) :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

negate :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

abs :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

signum :: Expression tables grouping params (Required (nullity ty)) -> Expression tables grouping params (Required (nullity ty))

fromInteger :: Integer -> Expression tables grouping params (Required (nullity ty))

Ord (Expression tables grouping params ty)

Methods

compare :: Expression tables grouping params ty -> Expression tables grouping params ty -> Ordering

(<) :: Expression tables grouping params ty -> Expression tables grouping params ty -> Bool

(<=) :: Expression tables grouping params ty -> Expression tables grouping params ty -> Bool

(>) :: Expression tables grouping params ty -> Expression tables grouping params ty -> Bool

(>=) :: Expression tables grouping params ty -> Expression tables grouping params ty -> Bool

max :: Expression tables grouping params ty -> Expression tables grouping params ty -> Expression tables grouping params ty

min :: Expression tables grouping params ty -> Expression tables grouping params ty -> Expression tables grouping params ty

Show (Expression tables grouping params ty)

Methods

showsPrec :: Int -> Expression tables grouping params ty -> ShowS

show :: Expression tables grouping params ty -> String

showList :: [Expression tables grouping params ty] -> ShowS

IsString (Expression tables grouping params (Required (nullity PGtext)))

Methods

fromString :: String -> Expression tables grouping params (Required (nullity PGtext))

Generic (Expression tables grouping params ty)

Associated Types

type Rep (Expression tables grouping params ty) :: * -> *

Methods

from :: Expression tables grouping params ty -> Rep (Expression tables grouping params ty) x

to :: Rep (Expression tables grouping params ty) x -> Expression tables grouping params ty

Monoid (Expression tables grouping params (Required (nullity PGtext)))

Methods

mempty :: Expression tables grouping params (Required (nullity PGtext))

mappend :: Expression tables grouping params (Required (nullity PGtext)) -> Expression tables grouping params (Required (nullity PGtext)) -> Expression tables grouping params (Required (nullity PGtext))

mconcat :: [Expression tables grouping params (Required (nullity PGtext))] -> Expression tables grouping params (Required (nullity PGtext))

NFData (Expression tables grouping params ty)

Methods

rnf :: Expression tables grouping params ty -> ()

type Rep (Expression tables grouping params ty)

type Rep (Expression tables grouping params ty) = D1 * (MetaData "Expression" "Squeal.PostgreSQL.Expression" "squeal-postgresql-0.1.1.4-k5IDJoGvjq2Crr3wWyEON" True) (C1 * (MetaCons "UnsafeExpression" PrefixI True) (S1 * (MetaSel (Just Symbol "renderExpression") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ByteString)))

class (PGTyped (BaseType ty), KnownNat n) => HasParameter (n :: Nat) params ty | n params -> ty where

A HasParameter constraint is used to indicate a value that is supplied externally to a SQL statement. manipulateParams, queryParams and traversePrepared support specifying data values separately from the SQL command string, in which case params are used to refer to the out-of-line data values.

Methods

param :: Expression tables grouping params ty

Instances

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

Methods

param :: Expression tables grouping ((ColumnType ': ty') params) ty

PGTyped (BaseType ty1) => HasParameter 1 ((:) ColumnType ty1 tys) ty1

Methods

param :: Expression tables grouping ((ColumnType ': ty1) tys) ty1

class KnownSymbol column => HasColumn column columns ty | column columns -> ty where

A HasColumn constraint indicates an unqualified column reference. getColumn can only be unambiguous when the TableExpression the column references is unique, in which case the column may be referenced using -XOverloadedLabels. Otherwise, combined with a HasTable constraint, the qualified column reference operator ! may be used.

Methods

getColumn :: HasUnique table tables columns => Alias column -> Expression tables Ungrouped params ty

Instances

(KnownSymbol column, HasColumn column table ty) => HasColumn column ((:) (Symbol, ColumnType) ty' table) ty

Methods

getColumn :: HasUnique ColumnsType table tables (((Symbol, ColumnType) ': ty') table) => Alias column -> Expression tables Ungrouped params ty

KnownSymbol column => HasColumn column ((:) (Symbol, ColumnType) ((:::) ColumnType column (optionality ty)) tys) (Required ty)

Methods

getColumn :: HasUnique ColumnsType table tables (((Symbol, ColumnType) ': (ColumnType ::: column) (optionality ty)) tys) => Alias column -> Expression tables Ungrouped params (Required ty)

data Column (columns :: ColumnsType) (columnty :: (Symbol, ColumnType)) where

A Column is a witness to a HasColumn constraint. It's used in unique and other TableConstraints to witness a subcolumns relationship.

Constructors

Column :: HasColumn column columns ty => Alias column -> Column columns (column ::: ty)

Instances

Eq (Column columns columnty)

Methods

(==) :: Column columns columnty -> Column columns columnty -> Bool

(/=) :: Column columns columnty -> Column columns columnty -> Bool

Ord (Column columns columnty)

Methods

compare :: Column columns columnty -> Column columns columnty -> Ordering

(<) :: Column columns columnty -> Column columns columnty -> Bool

(<=) :: Column columns columnty -> Column columns columnty -> Bool

(>) :: Column columns columnty -> Column columns columnty -> Bool

(>=) :: Column columns columnty -> Column columns columnty -> Bool

max :: Column columns columnty -> Column columns columnty -> Column columns columnty

min :: Column columns columnty -> Column columns columnty -> Column columns columnty

Show (Column columns columnty)

Methods

showsPrec :: Int -> Column columns columnty -> ShowS

show :: Column columns columnty -> String

showList :: [Column columns columnty] -> ShowS

renderColumn :: Column columns columnty -> ByteString

Render a Column.

class (KnownSymbol table, KnownSymbol column) => GroupedBy table column bys where

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.

Methods

getGroup1 :: (HasUnique table tables columns, HasColumn column columns ty) => Alias column -> Expression tables (Grouped bys) params ty

getGroup2 :: (HasTable table tables columns, HasColumn column columns ty) => Alias table -> Alias column -> Expression tables (Grouped bys) params ty

Instances

(KnownSymbol table, KnownSymbol column, GroupedBy table column bys) => GroupedBy table column ((:) (Symbol, Symbol) tabcol bys)

Methods

getGroup1 :: (HasUnique ColumnsType table tables columns, HasColumn column columns ty) => Alias column -> Expression tables (Grouped (((Symbol, Symbol) ': tabcol) bys)) params ty

getGroup2 :: (HasTable table tables columns, HasColumn column columns ty) => Alias table -> Alias column -> Expression tables (Grouped (((Symbol, Symbol) ': tabcol) bys)) params ty

(KnownSymbol table, KnownSymbol column) => GroupedBy table column ((:) (Symbol, Symbol) ((,) Symbol Symbol table column) bys)

Methods

getGroup1 :: (HasUnique ColumnsType table tables columns, HasColumn column columns ty) => Alias column -> Expression tables (Grouped (((Symbol, Symbol) ': (Symbol, Symbol) table column) bys)) params ty

getGroup2 :: (HasTable table tables columns, HasColumn column columns ty) => Alias table -> Alias column -> Expression tables (Grouped (((Symbol, Symbol) ': (Symbol, Symbol) table column) bys)) params ty

Default

def :: Expression '[] Ungrouped params (Optional (nullity ty))

>>> renderExpression def
"DEFAULT"

unDef

Arguments

:: Expression '[] Ungrouped params (Required (nullity ty))

not DEFAULT

-> Expression '[] Ungrouped params (Optional (nullity ty))

>>> renderExpression $ unDef false
"FALSE"

Null

null_ :: Expression tables grouping params (optionality (Null ty))

analagous to Nothing

>>> renderExpression $ null_
"NULL"

unNull

Arguments

:: Expression tables grouping params (optionality (NotNull ty))

not NULL

-> Expression tables grouping params (optionality (Null ty))

analagous to Just

>>> renderExpression $ unNull true
"TRUE"

coalesce

Arguments

:: [Expression tables grouping params (Required (Null ty))]

NULLs may be present

-> Expression tables grouping params (Required (NotNull ty))

NULL is absent

-> Expression tables grouping params (Required (NotNull ty))

return the leftmost value which is not NULL

>>> renderExpression $ coalesce [null_, unNull true] false
"COALESCE(NULL, TRUE, FALSE)"

fromNull

Arguments

:: Expression tables grouping params (Required (NotNull ty))

what to convert NULL to

-> Expression tables grouping params (Required (Null ty))

-> Expression tables grouping params (Required (NotNull ty))

analagous to fromMaybe using COALESCE

>>> renderExpression $ fromNull true null_
"COALESCE(NULL, TRUE)"

isNull

Arguments

:: Expression tables grouping params (Required (Null ty))

possibly NULL

-> Condition tables grouping params

>>> renderExpression $ null_ & isNull
"NULL IS NULL"

isn'tNull

Arguments

:: Expression tables grouping params (Required (Null ty))

possibly NULL

-> Condition tables grouping params

>>> renderExpression $ null_ & isn'tNull
"NULL IS NOT NULL"

matchNull

Arguments

:: Expression tables grouping params (Required nullty)

what to convert NULL to

-> (Expression tables grouping params (Required (NotNull ty)) -> Expression tables grouping params (Required nullty))

function to perform when NULL is absent

-> Expression tables grouping params (Required (Null ty))

-> Expression tables grouping params (Required nullty)

analagous to maybe using IS NULL

>>> renderExpression $ matchNull true not_ null_
"CASE WHEN NULL IS NULL THEN TRUE ELSE (NOT NULL) END"

nullIf

Arguments

:: Expression tables grouping params (Required (NotNull ty))

NULL is absent

-> Expression tables grouping params (Required (NotNull ty))

NULL is absent

-> Expression tables grouping params (Required (Null ty))

right inverse to fromNull, if its arguments are equal then nullIf gives NULL.

>>> :set -XTypeApplications -XDataKinds
>>> renderExpression @_ @_ @'[_] $ fromNull false (nullIf false (param @1))
"COALESCE(NULL IF (FALSE, ($1 :: bool)), FALSE)"

Functions

unsafeBinaryOp

Arguments

:: ByteString

operator

-> Expression tables grouping params (Required ty0)

-> Expression tables grouping params (Required ty1)

-> Expression tables grouping params (Required ty2)

>>> renderExpression $ unsafeBinaryOp "OR" true false
"(TRUE OR FALSE)"

unsafeUnaryOp

Arguments

:: ByteString

operator

-> Expression tables grouping params (Required ty0)

-> Expression tables grouping params (Required ty1)

>>> renderExpression $ unsafeUnaryOp "NOT" true
"(NOT TRUE)"

unsafeFunction

Arguments

:: ByteString

function

-> Expression tables grouping params (Required xty)

-> Expression tables grouping params (Required yty)

>>> renderExpression $ unsafeFunction "f" true
"f(TRUE)"

atan2_

Arguments

:: PGFloating float

=> Expression tables grouping params (Required (nullity float))

numerator

-> Expression tables grouping params (Required (nullity float))

denominator

-> Expression tables grouping params (Required (nullity float))

>>> renderExpression @_ @_ @_ @(_ (_ 'PGfloat4)) $ atan2_ pi 2
"atan2(pi(), 2)"

cast

Arguments

:: TypeExpression (Required (Null ty1))

type to cast as

-> Expression tables grouping params (Required (nullity ty0))

value to convert

-> Expression tables grouping params (Required (nullity ty1))

>>> renderExpression $ true & cast int4
"(TRUE :: int4)"

quot_

Arguments

:: PGIntegral int

=> Expression tables grouping params (Required (nullity int))

numerator

-> Expression tables grouping params (Required (nullity int))

denominator

-> Expression tables grouping params (Required (nullity int))

integer division, truncates the result

>>> renderExpression @_ @_ @_ @(_(_ 'PGint2)) $ 5 `quot_` 2
"(5 / 2)"

rem_

Arguments

:: PGIntegral int

=> Expression tables grouping params (Required (nullity int))

numerator

-> Expression tables grouping params (Required (nullity int))

denominator

-> Expression tables grouping params (Required (nullity int))

remainder upon integer division

>>> renderExpression @_ @_ @_ @(_ (_ 'PGint2)) $ 5 `rem_` 2
"(5 % 2)"

trunc

Arguments

:: PGFloating frac

=> Expression tables grouping params (Required (nullity frac))

fractional number

-> Expression tables grouping params (Required (nullity frac))

>>> renderExpression @_ @_ @_ @(_ (_ 'PGfloat4)) $ trunc pi
"trunc(pi())"

round_

Arguments

:: PGFloating frac

=> Expression tables grouping params (Required (nullity frac))

fractional number

-> Expression tables grouping params (Required (nullity frac))

>>> renderExpression @_ @_ @_ @(_ (_ 'PGfloat4)) $ round_ pi
"round(pi())"

ceiling_

Arguments

:: PGFloating frac

=> Expression tables grouping params (Required (nullity frac))

fractional number

-> Expression tables grouping params (Required (nullity frac))

>>> renderExpression @_ @_ @_ @(_ (_ 'PGfloat4)) $ ceiling_ pi
"ceiling(pi())"

greatest

Arguments

:: Expression tables grouping params (Required nullty)

needs at least 1 argument

-> [Expression tables grouping params (Required nullty)]

or more

-> Expression tables grouping params (Required nullty)

>>> renderExpression @_ @_ @'[_] $ greatest currentTimestamp [param @1]
"GREATEST(CURRENT_TIMESTAMP, ($1 :: timestamp with time zone))"

least

Arguments

:: Expression tables grouping params (Required nullty)

needs at least 1 argument

-> [Expression tables grouping params (Required nullty)]

or more

-> Expression tables grouping params (Required nullty)

>>> renderExpression $ least currentTimestamp [null_]
"LEAST(CURRENT_TIMESTAMP, NULL)"

Conditions

type Condition tables grouping params = Expression tables grouping params (Required (NotNull PGbool))

A Condition is a boolean valued Expression. While SQL allows conditions to have NULL, squeal instead chooses to disallow NULL, forcing one to handle the case of NULL explicitly to produce a Condition.

true :: Condition tables grouping params

>>> renderExpression true
"TRUE"

false :: Condition tables grouping params

>>> renderExpression false
"FALSE"

not_ :: Condition tables grouping params -> Condition tables grouping params

>>> renderExpression $ not_ true
"(NOT TRUE)"

(.&&) :: Condition tables grouping params -> Condition tables grouping params -> Condition tables grouping params

>>> renderExpression $ true .&& false
"(TRUE AND FALSE)"

(.||) :: Condition tables grouping params -> Condition tables grouping params -> Condition tables grouping params

>>> renderExpression $ true .|| false
"(TRUE OR FALSE)"

caseWhenThenElse :: [(Condition tables grouping params, Expression tables grouping params (Required ty))] -> Expression tables grouping params (Required ty) -> Expression tables grouping params (Required ty)

>>> renderExpression @_ @_ @_ @(_ (_ 'PGint2)) $ caseWhenThenElse [(true, 1), (false, 2)] 3
"CASE WHEN TRUE THEN 1 WHEN FALSE THEN 2 ELSE 3 END"

ifThenElse :: Condition tables grouping params -> Expression tables grouping params (Required ty) -> Expression tables grouping params (Required ty) -> Expression tables grouping params (Required ty)

>>> renderExpression @_ @_ @_ @(_ (_ 'PGint2)) $ ifThenElse true 1 0
"CASE WHEN TRUE THEN 1 ELSE 0 END"

(.==) infix 4

Arguments

:: Expression tables grouping params (Required (nullity ty))

lhs

-> Expression tables grouping params (Required (nullity ty))

rhs

-> Expression tables grouping params (Required (nullity PGbool))

Comparison operations like .==, ./=, .>, .>=, .< and .<= will produce NULLs if one of their arguments is NULL.

>>> renderExpression $ unNull true .== null_
"(TRUE = NULL)"

(./=) infix 4

Arguments

:: Expression tables grouping params (Required (nullity ty))

lhs

-> Expression tables grouping params (Required (nullity ty))

rhs

-> Expression tables grouping params (Required (nullity PGbool))

>>> renderExpression $ unNull true ./= null_
"(TRUE <> NULL)"

(.>=) infix 4

Arguments

:: Expression tables grouping params (Required (nullity ty))

lhs

-> Expression tables grouping params (Required (nullity ty))

rhs

-> Expression tables grouping params (Required (nullity PGbool))

>>> renderExpression $ unNull true .>= null_
"(TRUE >= NULL)"

(.<) infix 4

Arguments

:: Expression tables grouping params (Required (nullity ty))

lhs

-> Expression tables grouping params (Required (nullity ty))

rhs

-> Expression tables grouping params (Required (nullity PGbool))

>>> renderExpression $ unNull true .< null_
"(TRUE < NULL)"

(.<=) infix 4

Arguments

:: Expression tables grouping params (Required (nullity ty))

lhs

-> Expression tables grouping params (Required (nullity ty))

rhs

-> Expression tables grouping params (Required (nullity PGbool))

>>> renderExpression $ unNull true .<= null_
"(TRUE <= NULL)"

(.>) infix 4

Arguments

:: Expression tables grouping params (Required (nullity ty))

lhs

-> Expression tables grouping params (Required (nullity ty))

rhs

-> Expression tables grouping params (Required (nullity PGbool))

>>> renderExpression $ unNull true .> null_
"(TRUE > NULL)"

Time

currentDate :: Expression tables grouping params (Required (nullity PGdate))

>>> renderExpression $ currentDate
"CURRENT_DATE"

currentTime :: Expression tables grouping params (Required (nullity PGtimetz))

>>> renderExpression $ currentTime
"CURRENT_TIME"

currentTimestamp :: Expression tables grouping params (Required (nullity PGtimestamptz))

>>> renderExpression $ currentTimestamp
"CURRENT_TIMESTAMP"

localTime :: Expression tables grouping params (Required (nullity PGtime))

>>> renderExpression $ localTime
"LOCALTIME"

localTimestamp :: Expression tables grouping params (Required (nullity PGtimestamp))

>>> renderExpression $ localTimestamp
"LOCALTIMESTAMP"

Text

lower

Arguments

:: Expression tables grouping params (Required (nullity PGtext))

string to lower case

-> Expression tables grouping params (Required (nullity PGtext))

>>> renderExpression $ lower "ARRRGGG"
"lower(E'ARRRGGG')"

upper

Arguments

:: Expression tables grouping params (Required (nullity PGtext))

string to upper case

-> Expression tables grouping params (Required (nullity PGtext))

>>> renderExpression $ upper "eeee"
"upper(E'eeee')"

charLength

Arguments

:: Expression tables grouping params (Required (nullity PGtext))

string to measure

-> Expression tables grouping params (Required (nullity PGint4))

>>> renderExpression $ charLength "four"
"char_length(E'four')"

like

Arguments

:: Expression tables grouping params (Required (nullity PGtext))

string

-> Expression tables grouping params (Required (nullity PGtext))

pattern

-> Expression tables grouping params (Required (nullity PGbool))

The like expression returns true if the string matches the supplied pattern. If pattern does not contain percent signs or underscores, then the pattern only represents the string itself; in that case like acts like the equals operator. An underscore (_) in pattern stands for (matches) any single character; a percent sign (%) matches any sequence of zero or more characters.

>>> renderExpression $ "abc" `like` "a%"
"(E'abc' LIKE E'a%')"

Aggregation

unsafeAggregate

Arguments

:: ByteString

aggregate function

-> Expression tables Ungrouped params (Required xty)

-> Expression tables (Grouped bys) params (Required yty)

escape hatch to define aggregate functions

unsafeAggregateDistinct

Arguments

:: ByteString

aggregate function

-> Expression tables Ungrouped params (Required xty)

-> Expression tables (Grouped bys) params (Required yty)

escape hatch to define aggregate functions over distinct values

sum_

Arguments

:: PGNum ty

=> Expression tables Ungrouped params (Required (nullity ty))

what to sum

-> Expression tables (Grouped bys) params (Required (nullity ty))

>>> renderExpression @'[_ ::: '["col" ::: 'Required (_ 'PGnumeric)]] $ sum_ #col
"sum(col)"

sumDistinct

Arguments

:: PGNum ty

=> Expression tables Ungrouped params (Required (nullity ty))

what to sum

-> Expression tables (Grouped bys) params (Required (nullity ty))

>>> renderExpression @'[_ ::: '["col" ::: 'Required (_ 'PGnumeric)]] $ sumDistinct #col
"sum(DISTINCT col)"

class PGAvg ty avg | ty -> avg where

A constraint for PGTypes that you can take averages of and the resulting PGType.

Methods

avg,avgDistinct

Arguments

:: Expression tables Ungrouped params (Required (nullity ty))

what to average

-> Expression tables (Grouped bys) params (Required (nullity avg))

Instances

PGAvg PGType PGint2 PGnumeric

Methods

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

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

PGAvg PGType PGint4 PGnumeric

Methods

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

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

PGAvg PGType PGint8 PGnumeric

Methods

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

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

PGAvg PGType PGnumeric PGnumeric

Methods

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

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

PGAvg PGType PGfloat4 PGfloat8

Methods

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

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

PGAvg PGType PGfloat8 PGfloat8

Methods

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

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

PGAvg PGType PGinterval PGinterval

Methods

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

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

bitAnd

Arguments

:: PGIntegral int

=> Expression tables Ungrouped params (Required (nullity int))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity int))

>>> renderExpression @'[_ ::: '["col" ::: 'Required (_ 'PGint4)]] $ bitAnd #col
"bit_and(col)"

bitOr

Arguments

:: PGIntegral int

=> Expression tables Ungrouped params (Required (nullity int))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity int))

>>> renderExpression @'[_ ::: '["col" ::: 'Required (_ 'PGint4)]] $ bitOr #col
"bit_or(col)"

boolAnd

Arguments

:: Expression tables Ungrouped params (Required (nullity PGbool))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity PGbool))

>>> renderExpression @'[_ ::: '["col" ::: 'Required (_ 'PGbool)]] $ boolAnd #col
"bool_and(col)"

boolOr

Arguments

:: Expression tables Ungrouped params (Required (nullity PGbool))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity PGbool))

>>> renderExpression @'[_ ::: '["col" ::: 'Required (_ 'PGbool)]] $ boolOr #col
"bool_or(col)"

bitAndDistinct

Arguments

:: PGIntegral int

=> Expression tables Ungrouped params (Required (nullity int))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity int))

>>> renderExpression @'[_ ::: '["col" ::: 'Required (_ 'PGint4)]] $ bitAndDistinct #col
"bit_and(DISTINCT col)"

bitOrDistinct

Arguments

:: PGIntegral int

=> Expression tables Ungrouped params (Required (nullity int))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity int))

>>> renderExpression @'[_ ::: '["col" ::: 'Required (_ 'PGint4)]] $ bitOrDistinct #col
"bit_or(DISTINCT col)"

boolAndDistinct

Arguments

:: Expression tables Ungrouped params (Required (nullity PGbool))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity PGbool))

>>> renderExpression @'[_ ::: '["col" ::: 'Required (_ 'PGbool)]] $ boolAndDistinct #col
"bool_and(DISTINCT col)"

boolOrDistinct

Arguments

:: Expression tables Ungrouped params (Required (nullity PGbool))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity PGbool))

>>> renderExpression @'[_ ::: '["col" ::: 'Required (_ 'PGbool)]] $ boolOrDistinct #col
"bool_or(DISTINCT col)"

countStar :: Expression tables (Grouped bys) params (Required (NotNull PGint8))

A special aggregation that does not require an input

>>> renderExpression countStar
"count(*)"

count

Arguments

:: Expression tables Ungrouped params (Required ty)

what to count

-> Expression tables (Grouped bys) params (Required (NotNull PGint8))

>>> renderExpression @'[_ ::: '["col" ::: 'Optional _]] $ count #col
"count(col)"

countDistinct

Arguments

:: Expression tables Ungrouped params (Required ty)

what to count

-> Expression tables (Grouped bys) params (Required (NotNull PGint8))

>>> renderExpression @'[_ ::: '["col" ::: 'Required _]] $ countDistinct #col
"count(DISTINCT col)"

every

Arguments

:: Expression tables Ungrouped params (Required (nullity PGbool))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity PGbool))

synonym for boolAnd

>>> renderExpression @'[_ ::: '["col" ::: 'Required (_ 'PGbool)]] $ every #col
"every(col)"

everyDistinct

Arguments

:: Expression tables Ungrouped params (Required (nullity PGbool))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity PGbool))

synonym for boolAndDistinct

>>> renderExpression @'[_ ::: '["col" ::: 'Required (_ 'PGbool)]] $ everyDistinct #col
"every(DISTINCT col)"

max_

Arguments

:: Expression tables Ungrouped params (Required (nullity ty))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity ty))

minimum and maximum aggregation

maxDistinct

Arguments

:: Expression tables Ungrouped params (Required (nullity ty))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity ty))

minimum and maximum aggregation

min_

Arguments

:: Expression tables Ungrouped params (Required (nullity ty))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity ty))

minimum and maximum aggregation

minDistinct

Arguments

:: Expression tables Ungrouped params (Required (nullity ty))

what to aggregate

-> Expression tables (Grouped bys) params (Required (nullity ty))

minimum and maximum aggregation

Tables

newtype Table (schema :: TablesType) (columns :: ColumnsType)

A Table from a schema without its alias with an IsLabel instance to call a table reference by its alias.

Constructors

UnsafeTable

Fields

• renderTable :: ByteString

Instances

HasTable table schema columns => IsLabel table (Table schema columns)

Methods

fromLabel :: Table schema columns

Eq (Table schema columns)

Methods

(==) :: Table schema columns -> Table schema columns -> Bool

(/=) :: Table schema columns -> Table schema columns -> Bool

Ord (Table schema columns)

Methods

compare :: Table schema columns -> Table schema columns -> Ordering

(<) :: Table schema columns -> Table schema columns -> Bool

(<=) :: Table schema columns -> Table schema columns -> Bool

(>) :: Table schema columns -> Table schema columns -> Bool

(>=) :: Table schema columns -> Table schema columns -> Bool

max :: Table schema columns -> Table schema columns -> Table schema columns

min :: Table schema columns -> Table schema columns -> Table schema columns

Show (Table schema columns)

Methods

showsPrec :: Int -> Table schema columns -> ShowS

show :: Table schema columns -> String

showList :: [Table schema columns] -> ShowS

Generic (Table schema columns)

Associated Types

type Rep (Table schema columns) :: * -> *

Methods

from :: Table schema columns -> Rep (Table schema columns) x

to :: Rep (Table schema columns) x -> Table schema columns

NFData (Table schema columns)

Methods

rnf :: Table schema columns -> ()

type Rep (Table schema columns)

type Rep (Table schema columns) = D1 * (MetaData "Table" "Squeal.PostgreSQL.Expression" "squeal-postgresql-0.1.1.4-k5IDJoGvjq2Crr3wWyEON" True) (C1 * (MetaCons "UnsafeTable" PrefixI True) (S1 * (MetaSel (Just Symbol "renderTable") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ByteString)))

class KnownSymbol table => HasTable table tables columns | table tables -> columns where

A HasTable constraint indicates a table reference.

Methods

getTable :: Alias table -> Table tables columns

Instances

(KnownSymbol table, HasTable table schema columns) => HasTable table ((:) (Symbol, ColumnsType) table' schema) columns

Methods

getTable :: Alias table -> Table (((Symbol, ColumnsType) ': table') schema) columns

KnownSymbol table => HasTable table ((:) (Symbol, ColumnsType) ((:::) ColumnsType table columns) tables) columns

Methods

getTable :: Alias table -> Table (((Symbol, ColumnsType) ': (ColumnsType ::: table) columns) tables) columns

TypeExpression

newtype TypeExpression (ty :: ColumnType)

TypeExpressions are used in casts and createTable commands.

Constructors

UnsafeTypeExpression

Fields

• renderTypeExpression :: ByteString

Instances

Eq (TypeExpression ty)

Methods

(==) :: TypeExpression ty -> TypeExpression ty -> Bool

(/=) :: TypeExpression ty -> TypeExpression ty -> Bool

Ord (TypeExpression ty)

Methods

compare :: TypeExpression ty -> TypeExpression ty -> Ordering

(<) :: TypeExpression ty -> TypeExpression ty -> Bool

(<=) :: TypeExpression ty -> TypeExpression ty -> Bool

(>) :: TypeExpression ty -> TypeExpression ty -> Bool

(>=) :: TypeExpression ty -> TypeExpression ty -> Bool

max :: TypeExpression ty -> TypeExpression ty -> TypeExpression ty

min :: TypeExpression ty -> TypeExpression ty -> TypeExpression ty

Show (TypeExpression ty)

Methods

showsPrec :: Int -> TypeExpression ty -> ShowS

show :: TypeExpression ty -> String

showList :: [TypeExpression ty] -> ShowS

Generic (TypeExpression ty)

Associated Types

type Rep (TypeExpression ty) :: * -> *

Methods

from :: TypeExpression ty -> Rep (TypeExpression ty) x

to :: Rep (TypeExpression ty) x -> TypeExpression ty

NFData (TypeExpression ty)

Methods

rnf :: TypeExpression ty -> ()

type Rep (TypeExpression ty)

type Rep (TypeExpression ty) = D1 * (MetaData "TypeExpression" "Squeal.PostgreSQL.Expression" "squeal-postgresql-0.1.1.4-k5IDJoGvjq2Crr3wWyEON" True) (C1 * (MetaCons "UnsafeTypeExpression" PrefixI True) (S1 * (MetaSel (Just Symbol "renderTypeExpression") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ByteString)))

class PGTyped (ty :: PGType) where

pgtype is a demoted version of a PGType

Minimal complete definition

pgtype

Methods

pgtype :: TypeExpression (Required (Null ty))

Instances

PGTyped PGbool

Methods

pgtype :: TypeExpression (Required (Null PGbool))

PGTyped PGint2

Methods

pgtype :: TypeExpression (Required (Null PGint2))

PGTyped PGint4

Methods

pgtype :: TypeExpression (Required (Null PGint4))

PGTyped PGint8

Methods

pgtype :: TypeExpression (Required (Null PGint8))

PGTyped PGnumeric

Methods

pgtype :: TypeExpression (Required (Null PGnumeric))

PGTyped PGfloat4

Methods

pgtype :: TypeExpression (Required (Null PGfloat4))

PGTyped PGfloat8

Methods

pgtype :: TypeExpression (Required (Null PGfloat8))

PGTyped PGtext

Methods

pgtype :: TypeExpression (Required (Null PGtext))

PGTyped PGbytea

Methods

pgtype :: TypeExpression (Required (Null PGbytea))

PGTyped PGtimestamp

Methods

pgtype :: TypeExpression (Required (Null PGtimestamp))

PGTyped PGtimestamptz

Methods

pgtype :: TypeExpression (Required (Null PGtimestamptz))

PGTyped PGdate

Methods

pgtype :: TypeExpression (Required (Null PGdate))

PGTyped PGtime

Methods

pgtype :: TypeExpression (Required (Null PGtime))

PGTyped PGtimetz

Methods

pgtype :: TypeExpression (Required (Null PGtimetz))

PGTyped PGinterval

Methods

pgtype :: TypeExpression (Required (Null PGinterval))

PGTyped PGuuid

Methods

pgtype :: TypeExpression (Required (Null PGuuid))

PGTyped PGjson

Methods

pgtype :: TypeExpression (Required (Null PGjson))

PGTyped PGjsonb

Methods

pgtype :: TypeExpression (Required (Null PGjsonb))

(KnownNat n, (<=) 1 n) => PGTyped (PGchar n)

Methods

pgtype :: TypeExpression (Required (Null (PGchar n)))

(KnownNat n, (<=) 1 n) => PGTyped (PGvarchar n)

Methods

pgtype :: TypeExpression (Required (Null (PGvarchar n)))

bool :: TypeExpression (Required (Null PGbool))

logical Boolean (true/false)

int2 :: TypeExpression (Required (Null PGint2))

signed two-byte integer

smallint :: TypeExpression (Required (Null PGint2))

signed two-byte integer

int4 :: TypeExpression (Required (Null PGint4))

signed four-byte integer

int :: TypeExpression (Required (Null PGint4))

signed four-byte integer

integer :: TypeExpression (Required (Null PGint4))

signed four-byte integer

int8 :: TypeExpression (Required (Null PGint8))

signed eight-byte integer

bigint :: TypeExpression (Required (Null PGint8))

signed eight-byte integer

numeric :: TypeExpression (Required (Null PGnumeric))

arbitrary precision numeric type

float4 :: TypeExpression (Required (Null PGfloat4))

single precision floating-point number (4 bytes)

real :: TypeExpression (Required (Null PGfloat4))

single precision floating-point number (4 bytes)

float8 :: TypeExpression (Required (Null PGfloat8))

double precision floating-point number (8 bytes)

doublePrecision :: TypeExpression (Required (Null PGfloat8))

double precision floating-point number (8 bytes)

serial2 :: TypeExpression (Optional (NotNull PGint2))

not a true type, but merely a notational convenience for creating unique identifier columns with type `PGint2

smallserial :: TypeExpression (Optional (NotNull PGint2))

not a true type, but merely a notational convenience for creating unique identifier columns with type `PGint2

serial4 :: TypeExpression (Optional (NotNull PGint4))

not a true type, but merely a notational convenience for creating unique identifier columns with type `PGint4

serial :: TypeExpression (Optional (NotNull PGint4))

not a true type, but merely a notational convenience for creating unique identifier columns with type `PGint4

serial8 :: TypeExpression (Optional (NotNull PGint8))

not a true type, but merely a notational convenience for creating unique identifier columns with type `PGint8

bigserial :: TypeExpression (Optional (NotNull PGint8))

not a true type, but merely a notational convenience for creating unique identifier columns with type `PGint8

text :: TypeExpression (Required (Null PGtext))

variable-length character string

char :: (KnownNat n, 1 <= n) => proxy n -> TypeExpression (Required (Null (PGchar n)))

fixed-length character string

character :: (KnownNat n, 1 <= n) => proxy n -> TypeExpression (Required (Null (PGchar n)))

fixed-length character string

varchar :: (KnownNat n, 1 <= n) => proxy n -> TypeExpression (Required (Null (PGvarchar n)))

variable-length character string

characterVarying :: (KnownNat n, 1 <= n) => proxy n -> TypeExpression (Required (Null (PGvarchar n)))

variable-length character string

bytea :: TypeExpression (Required (Null PGbytea))

binary data ("byte array")

timestamp :: TypeExpression (Required (Null PGtimestamp))

date and time (no time zone)

timestampWithTimeZone :: TypeExpression (Required (Null PGtimestamptz))

date and time, including time zone

date :: TypeExpression (Required (Null PGdate))

calendar date (year, month, day)

time :: TypeExpression (Required (Null PGtime))

time of day (no time zone)

timeWithTimeZone :: TypeExpression (Required (Null PGtimetz))

time of day, including time zone

interval :: TypeExpression (Required (Null PGinterval))

time span

uuid :: TypeExpression (Required (Null PGuuid))

universally unique identifier

inet :: TypeExpression (Required (Null PGinet))

IPv4 or IPv6 host address

json :: TypeExpression (Required (Null PGjson))

textual JSON data

jsonb :: TypeExpression (Required (Null PGjsonb))

binary JSON data, decomposed

notNull :: TypeExpression (optionality (Null ty)) -> TypeExpression (optionality (NotNull ty))

used in createTable commands as a column constraint to ensure NULL is not present

default_ :: Expression '[] Ungrouped '[] (Required ty) -> TypeExpression (Required ty) -> TypeExpression (Optional ty)

used in createTable commands as a column constraint to give a default

Re-export

(&) :: a -> (a -> b) -> b infixl 1

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

Since: 4.8.0.0

data NP k (a :: k -> *) (b :: [k]) :: forall k. (k -> *) -> [k] -> * where

An n-ary product.

The product is parameterized by a type constructor f and indexed by a type-level list xs. The length of the list determines the number of elements in the product, and if the i-th element of the list is of type x, then the i-th element of the product is of type f x.

The constructor names are chosen to resemble the names of the list constructors.

Two common instantiations of f are the identity functor I and the constant functor K. For I, the product becomes a heterogeneous list, where the type-level list describes the types of its components. For K a, the product becomes a homogeneous list, where the contents of the type-level list are ignored, but its length still specifies the number of elements.

In the context of the SOP approach to generic programming, an n-ary product describes the structure of the arguments of a single data constructor.

Examples:

I 'x'    :* I True  :* Nil  ::  NP I       '[ Char, Bool ]
K 0      :* K 1     :* Nil  ::  NP (K Int) '[ Char, Bool ]
Just 'x' :* Nothing :* Nil  ::  NP Maybe   '[ Char, Bool ]

Constructors

Nil :: NP k a ([] k)

(:*) :: NP k a ((:) k x xs) infixr 5

Instances

HTrans k1 [k1] k2 [k2] (NP k1) (NP k2)

Methods

htrans :: AllZipN (NP k1) (NP k2) (NP k1) k2 (NP k2) l2 (Prod (NP k1) (NP k2) h1) c xs ys => proxy c -> (forall (x :: NP k1) (y :: k2). c x y => f x -> g y) -> h1 f xs -> h2 g ys

hcoerce :: (AllZipN (NP k1) (NP k2) (NP k1) k2 (NP k2) l2 (Prod (NP k1) (NP k2) h1) (LiftedCoercible * (NP k1) k2 f g) xs ys, HTrans (NP k1) (NP k2) k2 l2 h1 h2) => h1 f xs -> h2 g ys

HPure k [k] (NP k)

Methods

hpure :: SListIN (NP k) l h xs => (forall (a :: NP k). f a) -> h f xs

hcpure :: AllN (NP k) l h c xs => proxy c -> (forall (a :: NP k). c a => f a) -> h f xs

HAp k [k] (NP k)

Methods

hap :: Prod (NP k) l h ((NP k -.-> f) g) xs -> h f xs -> h g xs

HCollapse k [k] (NP k)

Methods

hcollapse :: SListIN (NP k) l h xs => h (K (NP k) a) xs -> CollapseTo (NP k) l h a

HSequence k [k] (NP k)

Methods

hsequence' :: (SListIN (NP k) l h xs, Applicative f) => h ((* :.: NP k) f g) xs -> f (h g xs)

All k (Compose * k Eq f) xs => Eq (NP k f xs)

Methods

(==) :: NP k f xs -> NP k f xs -> Bool

(/=) :: NP k f xs -> NP k f xs -> Bool

(All k (Compose * k Eq f) xs, All k (Compose * k Ord f) xs) => Ord (NP k f xs)

Methods

compare :: NP k f xs -> NP k f xs -> Ordering

(<) :: NP k f xs -> NP k f xs -> Bool

(<=) :: NP k f xs -> NP k f xs -> Bool

(>) :: NP k f xs -> NP k f xs -> Bool

(>=) :: NP k f xs -> NP k f xs -> Bool

max :: NP k f xs -> NP k f xs -> NP k f xs

min :: NP k f xs -> NP k f xs -> NP k f xs

All k (Compose * k Show f) xs => Show (NP k f xs)

Methods

showsPrec :: Int -> NP k f xs -> ShowS

show :: NP k f xs -> String

showList :: [NP k f xs] -> ShowS

All k (Compose * k NFData f) xs => NFData (NP k f xs)

Since: 0.2.5.0

Methods

rnf :: NP k f xs -> ()

type AllZipN k [k] a b [a] [b] (NP k) c

type AllZipN k [k] a b [a] [b] (NP k) c = AllZip a b c

type Same k1 [k1] k2 [k2] (NP k1)

type Same k1 [k1] k2 [k2] (NP k1) = NP k2

type Prod k [k] (NP k)

type Prod k [k] (NP k) = NP k

type UnProd k [k] (NP k)

type UnProd k [k] (NP k) = NS k

type SListIN k [k] (NP k)

type SListIN k [k] (NP k) = SListI k

type CollapseTo k [k] (NP k) a

type CollapseTo k [k] (NP k) a = [a]

type AllN k [k] (NP k) c

type AllN k [k] (NP k) c = All k c