Squeal.PostgreSQL.Expression

Squeal expressions are the atoms used to build statements.

Expression

newtype Expression (schema :: SchemaType) (relations :: RelationsType) (grouping :: Grouping) (params :: [NullityType]) (ty :: NullityType)

Expressions are used in a variety of contexts, such as in the target list of the select command, as new column values in insertRow 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

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

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

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

Eq (Expression schema relations grouping params ty)

Defined in Squeal.PostgreSQL.Expression

Methods

(==) :: Expression schema relations grouping params ty -> Expression schema relations grouping params ty -> Bool

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

(PGNum ty, PGFloating ty) => Floating (Expression schema relations grouping params (nullity ty))

Defined in Squeal.PostgreSQL.Expression

Methods

pi :: Expression schema relations grouping params (nullity ty)

exp :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

log :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

sqrt :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

(**) :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

logBase :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

sin :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

cos :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

tan :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

asin :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

acos :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

atan :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

sinh :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

cosh :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

tanh :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

asinh :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

acosh :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

atanh :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

log1p :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

expm1 :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

log1pexp :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

log1mexp :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

(PGNum ty, PGFloating ty) => Fractional (Expression schema relations grouping params (nullity ty))

Defined in Squeal.PostgreSQL.Expression

Methods

(/) :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

recip :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

fromRational :: Rational -> Expression schema relations grouping params (nullity ty)

PGNum ty => Num (Expression schema relations grouping params (nullity ty))

Defined in Squeal.PostgreSQL.Expression

Methods

(+) :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

(-) :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

(*) :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

negate :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

abs :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

signum :: Expression schema relations grouping params (nullity ty) -> Expression schema relations grouping params (nullity ty)

fromInteger :: Integer -> Expression schema relations grouping params (nullity ty)

Ord (Expression schema relations grouping params ty)

Defined in Squeal.PostgreSQL.Expression

Methods

compare :: Expression schema relations grouping params ty -> Expression schema relations grouping params ty -> Ordering

(<) :: Expression schema relations grouping params ty -> Expression schema relations grouping params ty -> Bool

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

(>) :: Expression schema relations grouping params ty -> Expression schema relations grouping params ty -> Bool

(>=) :: Expression schema relations grouping params ty -> Expression schema relations grouping params ty -> Bool

max :: Expression schema relations grouping params ty -> Expression schema relations grouping params ty -> Expression schema relations grouping params ty

min :: Expression schema relations grouping params ty -> Expression schema relations grouping params ty -> Expression schema relations grouping params ty

Show (Expression schema relations grouping params ty)

Defined in Squeal.PostgreSQL.Expression

Methods

showsPrec :: Int -> Expression schema relations grouping params ty -> ShowS

show :: Expression schema relations grouping params ty -> String

showList :: [Expression schema relations grouping params ty] -> ShowS

IsString (Expression schema relations grouping params (nullity PGtext))

Defined in Squeal.PostgreSQL.Expression

Methods

fromString :: String -> Expression schema relations grouping params (nullity PGtext)

Generic (Expression schema relations grouping params ty)

Defined in Squeal.PostgreSQL.Expression

Associated Types

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

Methods

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

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

Semigroup (Expression schema relations grouping params (nullity PGtext))

Defined in Squeal.PostgreSQL.Expression

Methods

(<>) :: Expression schema relations grouping params (nullity PGtext) -> Expression schema relations grouping params (nullity PGtext) -> Expression schema relations grouping params (nullity PGtext)

sconcat :: NonEmpty (Expression schema relations grouping params (nullity PGtext)) -> Expression schema relations grouping params (nullity PGtext)

stimes :: Integral b => b -> Expression schema relations grouping params (nullity PGtext) -> Expression schema relations grouping params (nullity PGtext)

Semigroup (Expression schema relations grouping params (nullity (PGvararray ty)))

Defined in Squeal.PostgreSQL.Expression

Methods

(<>) :: Expression schema relations grouping params (nullity (PGvararray ty)) -> Expression schema relations grouping params (nullity (PGvararray ty)) -> Expression schema relations grouping params (nullity (PGvararray ty))

sconcat :: NonEmpty (Expression schema relations grouping params (nullity (PGvararray ty))) -> Expression schema relations grouping params (nullity (PGvararray ty))

stimes :: Integral b => b -> Expression schema relations grouping params (nullity (PGvararray ty)) -> Expression schema relations grouping params (nullity (PGvararray ty))

Monoid (Expression schema relations grouping params (nullity PGtext))

Defined in Squeal.PostgreSQL.Expression

Methods

mempty :: Expression schema relations grouping params (nullity PGtext)

mappend :: Expression schema relations grouping params (nullity PGtext) -> Expression schema relations grouping params (nullity PGtext) -> Expression schema relations grouping params (nullity PGtext)

mconcat :: [Expression schema relations grouping params (nullity PGtext)] -> Expression schema relations grouping params (nullity PGtext)

Monoid (Expression schema relations grouping params (nullity (PGvararray ty)))

Defined in Squeal.PostgreSQL.Expression

Methods

mempty :: Expression schema relations grouping params (nullity (PGvararray ty))

mappend :: Expression schema relations grouping params (nullity (PGvararray ty)) -> Expression schema relations grouping params (nullity (PGvararray ty)) -> Expression schema relations grouping params (nullity (PGvararray ty))

mconcat :: [Expression schema relations grouping params (nullity (PGvararray ty))] -> Expression schema relations grouping params (nullity (PGvararray ty))

NFData (Expression schema relations grouping params ty)

Defined in Squeal.PostgreSQL.Expression

Methods

rnf :: Expression schema relations grouping params ty -> ()

RenderSQL (Expression schema relations grouping params ty)

Defined in Squeal.PostgreSQL.Expression

Methods

renderSQL :: Expression schema relations grouping params ty -> ByteString

type Rep (Expression schema relations grouping params ty)

Defined in Squeal.PostgreSQL.Expression

type Rep (Expression schema relations grouping params ty) = D1 (MetaData "Expression" "Squeal.PostgreSQL.Expression" "squeal-postgresql-0.3.1.0-DNDeh0HTANH3vXYqblRMwD" True) (C1 (MetaCons "UnsafeExpression" PrefixI True) (S1 (MetaSel (Just "renderExpression") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)))

class KnownNat n => HasParameter (n :: Nat) (schema :: SchemaType) (params :: [NullityType]) (ty :: NullityType) | 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

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

parameter takes a Nat using type application and a TypeExpression.

>>> let expr = parameter @1 int4 :: Expression sch rels grp '[ 'Null 'PGint4] ('Null 'PGint4)
>>> printSQL expr
($1 :: int4)

Instances

(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

param

Arguments

:: (PGTyped schema (PGTypeOf ty), HasParameter n schema params ty)

=> Expression schema relations grouping params ty

param

param takes a Nat using type application and for basic types, infers a TypeExpression.

>>> let expr = param @1 :: Expression sch rels grp '[ 'Null 'PGint4] ('Null 'PGint4)
>>> printSQL expr
($1 :: int4)

Null

null_ :: Expression schema rels grouping params (Null ty)

analagous to Nothing

>>> printSQL null_
NULL

notNull :: Expression schema rels grouping params (NotNull ty) -> Expression schema rels grouping params (Null ty)

analagous to Just

>>> printSQL $ notNull true
TRUE

coalesce

Arguments

:: [Expression schema relations grouping params (Null ty)]

NULLs may be present

-> Expression schema relations grouping params (NotNull ty)

NULL is absent

-> Expression schema relations grouping params (NotNull ty)

return the leftmost value which is not NULL

>>> printSQL $ coalesce [null_, notNull true] false
COALESCE(NULL, TRUE, FALSE)

fromNull

Arguments

:: Expression schema relations grouping params (NotNull ty)

what to convert NULL to

-> Expression schema relations grouping params (Null ty)

-> Expression schema relations grouping params (NotNull ty)

analagous to fromMaybe using COALESCE

>>> printSQL $ fromNull true null_
COALESCE(NULL, TRUE)

isNull

Arguments

:: Expression schema relations grouping params (Null ty)

possibly NULL

-> Condition schema relations grouping params

>>> printSQL $ null_ & isNull
NULL IS NULL

isNotNull

Arguments

:: Expression schema relations grouping params (Null ty)

possibly NULL

-> Condition schema relations grouping params

>>> printSQL $ null_ & isNotNull
NULL IS NOT NULL

matchNull

Arguments

:: Expression schema relations grouping params nullty

what to convert NULL to

-> (Expression schema relations grouping params (NotNull ty) -> Expression schema relations grouping params nullty)

function to perform when NULL is absent

-> Expression schema relations grouping params (Null ty)

-> Expression schema relations grouping params nullty

analagous to maybe using IS NULL

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

nullIf

Arguments

:: Expression schema relations grouping params (NotNull ty)

NULL is absent

-> Expression schema relations grouping params (NotNull ty)

NULL is absent

-> Expression schema relations grouping params (Null ty)

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

>>> :set -XTypeApplications -XDataKinds
>>> let expr = nullIf false (param @1) :: Expression schema rels grp '[ 'NotNull 'PGbool] ('Null 'PGbool)
>>> printSQL expr
NULL IF (FALSE, ($1 :: bool))

Collections

array

Arguments

:: [Expression schema relations grouping params (Null ty)]

array elements

-> Expression schema relations grouping params (nullity (PGvararray ty))

>>> printSQL $ array [null_, notNull false, notNull true]
ARRAY[NULL, FALSE, TRUE]

row

Arguments

:: SListI (Nulls fields)

=> NP (Aliased (Expression schema relations grouping params)) (Nulls fields)

zero or more expressions for the row field values

-> Expression schema relations grouping params (nullity (PGcomposite fields))

A row constructor is an expression that builds a row value (also called a composite value) using values for its member fields.

>>> type Complex = PGcomposite '["real" ::: 'PGfloat8, "imaginary" ::: 'PGfloat8]
>>> let i = row (0 `as` #real :* 1 `as` #imaginary) :: Expression '[] '[] 'Ungrouped '[] ('NotNull Complex)
>>> printSQL i
ROW(0, 1)

Functions

unsafeBinaryOp

Arguments

:: ByteString

operator

-> Expression schema relations grouping params ty0

-> Expression schema relations grouping params ty1

-> Expression schema relations grouping params ty2

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

unsafeUnaryOp

Arguments

:: ByteString

operator

-> Expression schema relations grouping params ty0

-> Expression schema relations grouping params ty1

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

unsafeFunction

Arguments

:: ByteString

function

-> Expression schema relations grouping params xty

-> Expression schema relations grouping params yty

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

atan2_

Arguments

:: PGFloating float

=> Expression schema relations grouping params (nullity float)

numerator

-> Expression schema relations grouping params (nullity float)

denominator

-> Expression schema relations grouping params (nullity float)

>>> :{
let
  expression :: Expression schema relations grouping params (nullity 'PGfloat4)
  expression = atan2_ pi 2
in printSQL expression
:}
atan2(pi(), 2)

cast

Arguments

:: TypeExpression schema ty1

type to cast as

-> Expression schema relations grouping params (nullity ty0)

value to convert

-> Expression schema relations grouping params (nullity ty1)

>>> printSQL $ true & cast int4
(TRUE :: int4)

quot_

Arguments

:: PGIntegral int

=> Expression schema relations grouping params (nullity int)

numerator

-> Expression schema relations grouping params (nullity int)

denominator

-> Expression schema relations grouping params (nullity int)

integer division, truncates the result

>>> :{
let
  expression :: Expression schema relations grouping params (nullity 'PGint2)
  expression = 5 `quot_` 2
in printSQL expression
:}
(5 / 2)

rem_

Arguments

:: PGIntegral int

=> Expression schema relations grouping params (nullity int)

numerator

-> Expression schema relations grouping params (nullity int)

denominator

-> Expression schema relations grouping params (nullity int)

remainder upon integer division

>>> :{
let
  expression :: Expression schema relations grouping params (nullity 'PGint2)
  expression = 5 `rem_` 2
in printSQL expression
:}
(5 % 2)

trunc

Arguments

:: PGFloating frac

=> Expression schema relations grouping params (nullity frac)

fractional number

-> Expression schema relations grouping params (nullity frac)

>>> :{
let
  expression :: Expression schema relations grouping params (nullity 'PGfloat4)
  expression = trunc pi
in printSQL expression
:}
trunc(pi())

round_

Arguments

:: PGFloating frac

=> Expression schema relations grouping params (nullity frac)

fractional number

-> Expression schema relations grouping params (nullity frac)

>>> :{
let
  expression :: Expression schema relations grouping params (nullity 'PGfloat4)
  expression = round_ pi
in printSQL expression
:}
round(pi())

ceiling_

Arguments

:: PGFloating frac

=> Expression schema relations grouping params (nullity frac)

fractional number

-> Expression schema relations grouping params (nullity frac)

>>> :{
let
  expression :: Expression schema relations grouping params (nullity 'PGfloat4)
  expression = ceiling_ pi
in printSQL expression
:}
ceiling(pi())

greatest

Arguments

:: Expression schema relations grouping params nullty

needs at least 1 argument

-> [Expression schema relations grouping params nullty]

or more

-> Expression schema relations grouping params nullty

>>> let expr = greatest currentTimestamp [param @1] :: Expression sch rels grp '[ 'NotNull 'PGtimestamptz] ('NotNull 'PGtimestamptz)
>>> printSQL expr
GREATEST(CURRENT_TIMESTAMP, ($1 :: timestamp with time zone))

least

Arguments

:: Expression schema relations grouping params nullty

needs at least 1 argument

-> [Expression schema relations grouping params nullty]

or more

-> Expression schema relations grouping params nullty

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

Conditions

type Condition schema relations grouping params = Expression schema relations grouping params (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 schema relations grouping params

>>> printSQL true
TRUE

false :: Condition schema relations grouping params

>>> printSQL false
FALSE

not_ :: Condition schema relations grouping params -> Condition schema relations grouping params

>>> printSQL $ not_ true
(NOT TRUE)

(.&&) :: Condition schema relations grouping params -> Condition schema relations grouping params -> Condition schema relations grouping params

>>> printSQL $ true .&& false
(TRUE AND FALSE)

(.||) :: Condition schema relations grouping params -> Condition schema relations grouping params -> Condition schema relations grouping params

>>> printSQL $ true .|| false
(TRUE OR FALSE)

caseWhenThenElse

Arguments

:: [(Condition schema relations grouping params, Expression schema relations grouping params ty)]

whens and thens

-> Expression schema relations grouping params ty

else

-> Expression schema relations grouping params ty

>>> :{
let
  expression :: Expression schema relations grouping params (nullity 'PGint2)
  expression = caseWhenThenElse [(true, 1), (false, 2)] 3
in printSQL expression
:}
CASE WHEN TRUE THEN 1 WHEN FALSE THEN 2 ELSE 3 END

ifThenElse

Arguments

:: Condition schema relations grouping params

-> Expression schema relations grouping params ty

then

-> Expression schema relations grouping params ty

else

-> Expression schema relations grouping params ty

>>> :{
let
  expression :: Expression schema relations grouping params (nullity 'PGint2)
  expression = ifThenElse true 1 0
in printSQL expression
:}
CASE WHEN TRUE THEN 1 ELSE 0 END

(.==) infix 4

Arguments

:: Expression schema relations grouping params (nullity ty)

lhs

-> Expression schema relations grouping params (nullity ty)

rhs

-> Expression schema relations grouping params (nullity PGbool)

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

>>> printSQL $ notNull true .== null_
(TRUE = NULL)

(./=) infix 4

Arguments

:: Expression schema relations grouping params (nullity ty)

lhs

-> Expression schema relations grouping params (nullity ty)

rhs

-> Expression schema relations grouping params (nullity PGbool)

>>> printSQL $ notNull true ./= null_
(TRUE <> NULL)

(.>=) infix 4

Arguments

:: Expression schema relations grouping params (nullity ty)

lhs

-> Expression schema relations grouping params (nullity ty)

rhs

-> Expression schema relations grouping params (nullity PGbool)

>>> printSQL $ notNull true .>= null_
(TRUE >= NULL)

(.<) infix 4

Arguments

:: Expression schema relations grouping params (nullity ty)

lhs

-> Expression schema relations grouping params (nullity ty)

rhs

-> Expression schema relations grouping params (nullity PGbool)

>>> printSQL $ notNull true .< null_
(TRUE < NULL)

(.<=) infix 4

Arguments

:: Expression schema relations grouping params (nullity ty)

lhs

-> Expression schema relations grouping params (nullity ty)

rhs

-> Expression schema relations grouping params (nullity PGbool)

>>> printSQL $ notNull true .<= null_
(TRUE <= NULL)

(.>) infix 4

Arguments

:: Expression schema relations grouping params (nullity ty)

lhs

-> Expression schema relations grouping params (nullity ty)

rhs

-> Expression schema relations grouping params (nullity PGbool)

>>> printSQL $ notNull true .> null_
(TRUE > NULL)

Time

currentDate :: Expression schema relations grouping params (nullity PGdate)

>>> printSQL currentDate
CURRENT_DATE

currentTime :: Expression schema relations grouping params (nullity PGtimetz)

>>> printSQL currentTime
CURRENT_TIME

currentTimestamp :: Expression schema relations grouping params (nullity PGtimestamptz)

>>> printSQL currentTimestamp
CURRENT_TIMESTAMP

localTime :: Expression schema relations grouping params (nullity PGtime)

>>> printSQL localTime
LOCALTIME

localTimestamp :: Expression schema relations grouping params (nullity PGtimestamp)

>>> printSQL localTimestamp
LOCALTIMESTAMP

Text

lower

Arguments

:: Expression schema relations grouping params (nullity PGtext)

string to lower case

-> Expression schema relations grouping params (nullity PGtext)

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

upper

Arguments

:: Expression schema relations grouping params (nullity PGtext)

string to upper case

-> Expression schema relations grouping params (nullity PGtext)

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

charLength

Arguments

:: Expression schema relations grouping params (nullity PGtext)

string to measure

-> Expression schema relations grouping params (nullity PGint4)

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

like

Arguments

:: Expression schema relations grouping params (nullity PGtext)

string

-> Expression schema relations grouping params (nullity PGtext)

pattern

-> Expression schema relations grouping params (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.

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

Aggregation

unsafeAggregate

Arguments

:: ByteString

aggregate function

-> Expression schema relations Ungrouped params xty

-> Expression schema relations (Grouped bys) params yty

escape hatch to define aggregate functions

unsafeAggregateDistinct

Arguments

:: ByteString

aggregate function

-> Expression schema relations Ungrouped params xty

-> Expression schema relations (Grouped bys) params yty

escape hatch to define aggregate functions over distinct values

sum_

Arguments

:: PGNum ty

=> Expression schema relations Ungrouped params (nullity ty)

what to sum

-> Expression schema relations (Grouped bys) params (nullity ty)

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: 'Null 'PGnumeric]] ('Grouped bys) params ('Null 'PGnumeric)
  expression = sum_ #col
in printSQL expression
:}
sum("col")

sumDistinct

Arguments

:: PGNum ty

=> Expression schema relations Ungrouped params (nullity ty)

what to sum

-> Expression schema relations (Grouped bys) params (nullity ty)

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: nullity 'PGnumeric]] ('Grouped bys) params (nullity 'PGnumeric)
  expression = sumDistinct #col
in printSQL expression
:}
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

Arguments

:: Expression schema relations Ungrouped params (nullity ty)

what to average

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

avgDistinct

Arguments

:: Expression schema relations Ungrouped params (nullity ty)

what to average

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

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)

bitAnd

Arguments

:: PGIntegral int

=> Expression schema relations Ungrouped params (nullity int)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity int)

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: nullity 'PGint4]] (Grouped bys) params (nullity 'PGint4)
  expression = bitAnd #col
in printSQL expression
:}
bit_and("col")

bitOr

Arguments

:: PGIntegral int

=> Expression schema relations Ungrouped params (nullity int)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity int)

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: nullity 'PGint4]] (Grouped bys) params (nullity 'PGint4)
  expression = bitOr #col
in printSQL expression
:}
bit_or("col")

boolAnd

Arguments

:: Expression schema relations Ungrouped params (nullity PGbool)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity PGbool)

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: nullity 'PGbool]] (Grouped bys) params (nullity 'PGbool)
  expression = boolAnd #col
in printSQL expression
:}
bool_and("col")

boolOr

Arguments

:: Expression schema relations Ungrouped params (nullity PGbool)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity PGbool)

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: nullity 'PGbool]] (Grouped bys) params (nullity 'PGbool)
  expression = boolOr #col
in printSQL expression
:}
bool_or("col")

bitAndDistinct

Arguments

:: PGIntegral int

=> Expression schema relations Ungrouped params (nullity int)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity int)

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: nullity 'PGint4]] (Grouped bys) params (nullity 'PGint4)
  expression = bitAndDistinct #col
in printSQL expression
:}
bit_and(DISTINCT "col")

bitOrDistinct

Arguments

:: PGIntegral int

=> Expression schema relations Ungrouped params (nullity int)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity int)

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: nullity 'PGint4]] (Grouped bys) params (nullity 'PGint4)
  expression = bitOrDistinct #col
in printSQL expression
:}
bit_or(DISTINCT "col")

boolAndDistinct

Arguments

:: Expression schema relations Ungrouped params (nullity PGbool)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity PGbool)

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: nullity 'PGbool]] (Grouped bys) params (nullity 'PGbool)
  expression = boolAndDistinct #col
in printSQL expression
:}
bool_and(DISTINCT "col")

boolOrDistinct

Arguments

:: Expression schema relations Ungrouped params (nullity PGbool)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity PGbool)

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: nullity 'PGbool]] (Grouped bys) params (nullity 'PGbool)
  expression = boolOrDistinct #col
in printSQL expression
:}
bool_or(DISTINCT "col")

countStar :: Expression schema relations (Grouped bys) params (NotNull PGint8)

A special aggregation that does not require an input

>>> printSQL countStar
count(*)

count

Arguments

:: Expression schema relations Ungrouped params ty

what to count

-> Expression schema relations (Grouped bys) params (NotNull PGint8)

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: nullity ty]] (Grouped bys) params ('NotNull 'PGint8)
  expression = count #col
in printSQL expression
:}
count("col")

countDistinct

Arguments

:: Expression schema relations Ungrouped params ty

what to count

-> Expression schema relations (Grouped bys) params (NotNull PGint8)

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: nullity ty]] (Grouped bys) params ('NotNull 'PGint8)
  expression = countDistinct #col
in printSQL expression
:}
count(DISTINCT "col")

every

Arguments

:: Expression schema relations Ungrouped params (nullity PGbool)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity PGbool)

synonym for boolAnd

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: nullity 'PGbool]] (Grouped bys) params (nullity 'PGbool)
  expression = every #col
in printSQL expression
:}
every("col")

everyDistinct

Arguments

:: Expression schema relations Ungrouped params (nullity PGbool)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity PGbool)

synonym for boolAndDistinct

>>> :{
let
  expression :: Expression schema '[tab ::: '["col" ::: nullity 'PGbool]] (Grouped bys) params (nullity 'PGbool)
  expression = everyDistinct #col
in printSQL expression
:}
every(DISTINCT "col")

max_

Arguments

:: Expression schema relations Ungrouped params (nullity ty)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity ty)

minimum and maximum aggregation

maxDistinct

Arguments

:: Expression schema relations Ungrouped params (nullity ty)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity ty)

minimum and maximum aggregation

min_

Arguments

:: Expression schema relations Ungrouped params (nullity ty)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity ty)

minimum and maximum aggregation

minDistinct

Arguments

:: Expression schema relations Ungrouped params (nullity ty)

what to aggregate

-> Expression schema relations (Grouped bys) params (nullity ty)

minimum and maximum aggregation

Types

newtype TypeExpression (schema :: SchemaType) (ty :: PGType)

TypeExpressions are used in casts and createTable commands.

Constructors

UnsafeTypeExpression

Fields

• renderTypeExpression :: ByteString

Instances

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

Defined in Squeal.PostgreSQL.Expression

Methods

fromLabel :: TypeExpression schema ty

Eq (TypeExpression schema ty)

Defined in Squeal.PostgreSQL.Expression

Methods

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

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

Ord (TypeExpression schema ty)

Defined in Squeal.PostgreSQL.Expression

Methods

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

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

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

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

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

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

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

Show (TypeExpression schema ty)

Defined in Squeal.PostgreSQL.Expression

Methods

showsPrec :: Int -> TypeExpression schema ty -> ShowS

show :: TypeExpression schema ty -> String

showList :: [TypeExpression schema ty] -> ShowS

Generic (TypeExpression schema ty)

Defined in Squeal.PostgreSQL.Expression

Associated Types

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

Methods

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

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

NFData (TypeExpression schema ty)

Defined in Squeal.PostgreSQL.Expression

Methods

rnf :: TypeExpression schema ty -> ()

type Rep (TypeExpression schema ty)

Defined in Squeal.PostgreSQL.Expression

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

class PGTyped schema (ty :: PGType) where

pgtype is a demoted version of a PGType

Minimal complete definition

pgtype

Methods

pgtype :: TypeExpression schema ty

Instances

PGTyped schema PGjsonb

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGjsonb

PGTyped schema PGjson

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGjson

PGTyped schema PGuuid

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGuuid

PGTyped schema PGinterval

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGinterval

PGTyped schema PGtimetz

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGtimetz

PGTyped schema PGtime

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGtime

PGTyped schema PGdate

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGdate

PGTyped schema PGtimestamptz

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGtimestamptz

PGTyped schema PGtimestamp

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGtimestamp

PGTyped schema PGbytea

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGbytea

PGTyped schema PGtext

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGtext

PGTyped schema PGfloat8

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGfloat8

PGTyped schema PGfloat4

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGfloat4

PGTyped schema PGnumeric

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGnumeric

PGTyped schema PGint8

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGint8

PGTyped schema PGint4

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGint4

PGTyped schema PGint2

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGint2

PGTyped schema PGbool

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema PGbool

PGTyped schema ty => PGTyped schema (PGvararray ty)

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema (PGvararray ty)

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

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema (PGvarchar n)

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

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema (PGchar n)

(KnownNat n, PGTyped schema ty) => PGTyped schema (PGfixarray n ty)

Defined in Squeal.PostgreSQL.Expression

Methods

pgtype :: TypeExpression schema (PGfixarray n ty)

bool :: TypeExpression schema PGbool

logical Boolean (true/false)

int2 :: TypeExpression schema PGint2

signed two-byte integer

smallint :: TypeExpression schema PGint2

signed two-byte integer

int4 :: TypeExpression schema PGint4

signed four-byte integer

int :: TypeExpression schema PGint4

signed four-byte integer

integer :: TypeExpression schema PGint4

signed four-byte integer

int8 :: TypeExpression schema PGint8

signed eight-byte integer

bigint :: TypeExpression schema PGint8

signed eight-byte integer

numeric :: TypeExpression schema PGnumeric

arbitrary precision numeric type

float4 :: TypeExpression schema PGfloat4

single precision floating-point number (4 bytes)

real :: TypeExpression schema PGfloat4

single precision floating-point number (4 bytes)

float8 :: TypeExpression schema PGfloat8

double precision floating-point number (8 bytes)

doublePrecision :: TypeExpression schema PGfloat8

double precision floating-point number (8 bytes)

text :: TypeExpression schema PGtext

variable-length character string

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

fixed-length character string

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

fixed-length character string

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

variable-length character string

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

variable-length character string

bytea :: TypeExpression schema PGbytea

binary data ("byte array")

timestamp :: TypeExpression schema PGtimestamp

date and time (no time zone)

timestampWithTimeZone :: TypeExpression schema PGtimestamptz

date and time, including time zone

date :: TypeExpression schema PGdate

calendar date (year, month, day)

time :: TypeExpression schema PGtime

time of day (no time zone)

timeWithTimeZone :: TypeExpression schema PGtimetz

time of day, including time zone

interval :: TypeExpression schema PGinterval

time span

uuid :: TypeExpression schema PGuuid

universally unique identifier

inet :: TypeExpression schema PGinet

IPv4 or IPv6 host address

json :: TypeExpression schema PGjson

textual JSON data

jsonb :: TypeExpression schema PGjsonb

binary JSON data, decomposed

vararray :: TypeExpression schema pg -> TypeExpression schema (PGvararray pg)

variable length array

fixarray :: KnownNat n => proxy n -> TypeExpression schema pg -> TypeExpression schema (PGfixarray n pg)

fixed length array

>>> renderTypeExpression (fixarray (Proxy @2) json)
"json[2]"

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

>>> 5 & (+1) & show
"6"

Since: base-4.8.0.0

data NP (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 a ([] :: [k])

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

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

HTrans (NP :: (k1 -> *) -> [k1] -> *) (NP :: (k2 -> *) -> [k2] -> *)

Defined in Generics.SOP.NP

Methods

htrans :: AllZipN (Prod NP) c xs ys => proxy c -> (forall (x :: k10) (y :: k20). c x y => f x -> g y) -> NP f xs -> NP g ys

hcoerce :: (AllZipN (Prod NP) (LiftedCoercible f g) xs ys, HTrans NP NP) => NP f xs -> NP g ys

HPure (NP :: (k -> *) -> [k] -> *)

Defined in Generics.SOP.NP

Methods

hpure :: SListIN NP xs => (forall (a :: k0). f a) -> NP f xs

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

HAp (NP :: (k -> *) -> [k] -> *)

Defined in Generics.SOP.NP

Methods

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

HCollapse (NP :: (k -> *) -> [k] -> *)

Defined in Generics.SOP.NP

Methods

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

HTraverse_ (NP :: (k -> *) -> [k] -> *)

Defined in Generics.SOP.NP

Methods

hctraverse_ :: (AllN NP c xs, Applicative g) => proxy c -> (forall (a :: k0). c a => f a -> g ()) -> NP f xs -> g ()

htraverse_ :: (SListIN NP xs, Applicative g) => (forall (a :: k0). f a -> g ()) -> NP f xs -> g ()

HSequence (NP :: (k -> *) -> [k] -> *)

Defined in Generics.SOP.NP

Methods

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

hctraverse' :: (AllN NP c xs, Applicative g) => proxy c -> (forall (a :: k0). c a => f a -> g (f' a)) -> NP f xs -> g (NP f' xs)

htraverse' :: (SListIN NP xs, Applicative g) => (forall (a :: k0). f a -> g (f' a)) -> NP f xs -> g (NP f' xs)

(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

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

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

Defined in Squeal.PostgreSQL.Schema

Methods

label :: NP PGlabel labels

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

Defined in Generics.SOP.NP

Methods

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

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

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

Defined in Generics.SOP.NP

Methods

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

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

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

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

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

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

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

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

Defined in Generics.SOP.NP

Methods

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

show :: NP f xs -> String

showList :: [NP f xs] -> ShowS

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

Since: generics-sop-0.2.5.0

Defined in Generics.SOP.NP

Methods

rnf :: NP f xs -> ()

type AllZipN (NP :: (k -> *) -> [k] -> *) (c :: a -> b -> Constraint)

Defined in Generics.SOP.NP

type AllZipN (NP :: (k -> *) -> [k] -> *) (c :: a -> b -> Constraint) = AllZip c

type Same (NP :: (k1 -> *) -> [k1] -> *)

Defined in Generics.SOP.NP

type Same (NP :: (k1 -> *) -> [k1] -> *) = (NP :: (k2 -> *) -> [k2] -> *)

type Prod (NP :: (k -> *) -> [k] -> *)

Defined in Generics.SOP.NP

type Prod (NP :: (k -> *) -> [k] -> *) = (NP :: (k -> *) -> [k] -> *)

type UnProd (NP :: (k -> *) -> [k] -> *)

Defined in Generics.SOP.NS

type UnProd (NP :: (k -> *) -> [k] -> *) = (NS :: (k -> *) -> [k] -> *)

type SListIN (NP :: (k -> *) -> [k] -> *)

Defined in Generics.SOP.NP

type SListIN (NP :: (k -> *) -> [k] -> *) = (SListI :: [k] -> Constraint)

type CollapseTo (NP :: (k -> *) -> [k] -> *) a

Defined in Generics.SOP.NP

type CollapseTo (NP :: (k -> *) -> [k] -> *) a = [a]

type AllN (NP :: (k -> *) -> [k] -> *) (c :: k -> Constraint)

Defined in Generics.SOP.NP

type AllN (NP :: (k -> *) -> [k] -> *) (c :: k -> Constraint) = All c