@@ -31,7 +31,7 @@ Squeal expressions are the atoms used to build statements.
32module Squeal.PostgreSQL.Expression
32module Squeal.PostgreSQL.Expression
33 ( -- * Expression
33 ( -- * Expression
34− Expression (UnsafeExpression, renderExpression)
34+ Expression (..)
35 , HasParameter (parameter)
35 , HasParameter (parameter)
37 -- ** Null
37 -- ** Null
@@ -142,8 +142,8 @@ module Squeal.PostgreSQL.Expression
142 , every, everyDistinct
142 , every, everyDistinct
143 , max_, maxDistinct, min_, minDistinct
143 , max_, maxDistinct, min_, minDistinct
144 -- * Types
144 -- * Types
145− , TypeExpression (UnsafeTypeExpression, renderTypeExpression)
145+ , TypeExpression (..)
146− , PGTyped (pgtype)
146+ , PGTyped (..)
147 , typedef
147 , typedef
148 , typetable
148 , typetable
149 , typeview
149 , typeview
@@ -219,14 +219,14 @@ and other operations.
220newtype Expression
220newtype Expression
221 (db :: DBType)
221 (db :: DBType)
223− (grouping :: Grouping)
224 (params :: [NullityType])
222 (params :: [NullityType])
225 (ty :: NullityType)
225 (ty :: NullityType)
226 = UnsafeExpression { renderExpression :: ByteString }
226 = UnsafeExpression { renderExpression :: ByteString }
227 deriving (GHC.Generic,Show,Eq,Ord,NFData)
227 deriving (GHC.Generic,Show,Eq,Ord,NFData)
229−instance RenderSQL (Expression db from grouping params ty) where
229+instance RenderSQL (Expression db params grp from ty) where
230 renderSQL = renderExpression
230 renderSQL = renderExpression
232{- | A `HasParameter` constraint is used to indicate a value that is
232{- | A `HasParameter` constraint is used to indicate a value that is
@@ -244,15 +244,15 @@ class KnownNat n => HasParameter
244 | n params -> ty where
244 | n params -> ty where
245 -- | `parameter` takes a `Nat` using type application and a `TypeExpression`.
245 -- | `parameter` takes a `Nat` using type application and a `TypeExpression`.
247− -- >>> let expr = parameter @1 int4 :: Expression (DBof schemas) from grp '[ 'Null 'PGint4] ('Null 'PGint4)
247+ -- >>> let expr = parameter @1 int4 :: Expression (DBof schemas) '[ 'Null 'PGint4] grp from ('Null 'PGint4)
248 -- >>> printSQL expr
248 -- >>> printSQL expr
249 -- ($1 :: int4)
249 -- ($1 :: int4)
250 parameter
250 parameter
251 :: TypeExpression schemas ty
251 :: TypeExpression schemas ty
252− -> Expression (commons :=> schemas) from grouping params ty
252+ -> Expression (commons :=> schemas) params grp from ty
253 parameter ty = UnsafeExpression $ parenthesized $
253 parameter ty = UnsafeExpression $ parenthesized $
254 "$" <> renderNat @n <+> "::"
254 "$" <> renderNat @n <+> "::"
255− <+> renderTypeExpression ty
255+ <+> renderSQL ty
256instance {-# OVERLAPPING #-} HasParameter 1 (ty1:tys) ty1
256instance {-# OVERLAPPING #-} HasParameter 1 (ty1:tys) ty1
257instance {-# OVERLAPPABLE #-} (KnownNat n, HasParameter (n-1) params ty)
257instance {-# OVERLAPPABLE #-} (KnownNat n, HasParameter (n-1) params ty)
258 => HasParameter n (ty' : params) ty
258 => HasParameter n (ty' : params) ty
@@ -260,88 +260,88 @@ instance {-# OVERLAPPABLE #-} (KnownNat n, HasParameter (n-1) params ty)
260-- | `param` takes a `Nat` using type application and for basic types,
260-- | `param` takes a `Nat` using type application and for basic types,
261-- infers a `TypeExpression`.
261-- infers a `TypeExpression`.
263−-- >>> let expr = param @1 :: Expression (commons :=> schemas) from grp '[ 'Null 'PGint4] ('Null 'PGint4)
263+-- >>> let expr = param @1 :: Expression (commons :=> schemas) '[ 'Null 'PGint4] grp from ('Null 'PGint4)
264-- >>> printSQL expr
264-- >>> printSQL expr
265-- ($1 :: int4)
265-- ($1 :: int4)
267− :: forall n db commons schemas params from grouping ty
267+ :: forall n db commons schemas params from grp ty
268 . (db ~ (commons :=> schemas), PGTyped schemas ty, HasParameter n params ty)
268 . (db ~ (commons :=> schemas), PGTyped schemas ty, HasParameter n params ty)
269− => Expression db from grouping params ty -- ^ param
269+ => Expression db params grp from ty -- ^ param
270param = parameter @n (pgtype @schemas)
270param = parameter @n (pgtype @schemas)
272instance (HasUnique tab from row, Has col row ty)
272instance (HasUnique tab from row, Has col row ty)
273− => IsLabel col (Expression db from 'Ungrouped params ty) where
273+ => IsLabel col (Expression db params 'Ungrouped from ty) where
274− fromLabel = UnsafeExpression $ renderAlias (Alias @col)
274+ fromLabel = UnsafeExpression $ renderSQL (Alias @col)
275instance (HasUnique tab from row, Has col row ty, column ~ (col ::: ty))
275instance (HasUnique tab from row, Has col row ty, column ~ (col ::: ty))
276 => IsLabel col
276 => IsLabel col
277− (Aliased (Expression db from 'Ungrouped params) column) where
277+ (Aliased (Expression db params 'Ungrouped from) column) where
278 fromLabel = fromLabel @col `As` Alias
278 fromLabel = fromLabel @col `As` Alias
279instance (HasUnique tab from row, Has col row ty, columns ~ '[col ::: ty])
279instance (HasUnique tab from row, Has col row ty, columns ~ '[col ::: ty])
280 => IsLabel col
280 => IsLabel col
281− (NP (Aliased (Expression db from 'Ungrouped params)) columns) where
281+ (NP (Aliased (Expression db params 'Ungrouped from)) columns) where
282 fromLabel = fromLabel @col :* Nil
282 fromLabel = fromLabel @col :* Nil
284instance (Has tab from row, Has col row ty)
284instance (Has tab from row, Has col row ty)
285− => IsQualified tab col (Expression db from 'Ungrouped params ty) where
285+ => IsQualified tab col (Expression db params 'Ungrouped from ty) where
286 tab ! col = UnsafeExpression $
286 tab ! col = UnsafeExpression $
287− renderAlias tab <> "." <> renderAlias col
287+ renderSQL tab <> "." <> renderSQL col
288instance (Has tab from row, Has col row ty, column ~ (col ::: ty))
288instance (Has tab from row, Has col row ty, column ~ (col ::: ty))
289 => IsQualified tab col
289 => IsQualified tab col
290− (Aliased (Expression db from 'Ungrouped params) column) where
290+ (Aliased (Expression db params 'Ungrouped from) column) where
291 tab ! col = tab ! col `As` col
291 tab ! col = tab ! col `As` col
292instance (Has tab from row, Has col row ty, columns ~ '[col ::: ty])
292instance (Has tab from row, Has col row ty, columns ~ '[col ::: ty])
293 => IsQualified tab col
293 => IsQualified tab col
294− (NP (Aliased (Expression db from 'Ungrouped params)) columns) where
294+ (NP (Aliased (Expression db params 'Ungrouped from)) columns) where
295 tab ! col = tab ! col :* Nil
295 tab ! col = tab ! col :* Nil
298− ( HasUnique table from columns
298+ ( HasUnique tab from row
299− , Has column columns ty
299+ , Has col row ty
300− , GroupedBy table column bys
300+ , GroupedBy tab col bys
301− ) => IsLabel column
301+ ) => IsLabel col
302− (Expression db from ('Grouped bys) params ty) where
302+ (Expression db params ('Grouped bys) from ty) where
303− fromLabel = UnsafeExpression $ renderAlias (Alias @column)
303+ fromLabel = UnsafeExpression $ renderSQL (Alias @col)
305− ( HasUnique table from columns
305+ ( HasUnique tab from row
306− , Has column columns ty
306+ , Has col row ty
307− , GroupedBy table column bys
307+ , GroupedBy tab col bys
308+ , column ~ (col ::: ty)
308− ) => IsLabel column
309+ ) => IsLabel col
309− ( Aliased (Expression db from ('Grouped bys) params)
310+ (Aliased (Expression db params ('Grouped bys) from) column) where
310− (column ::: ty) ) where
311− fromLabel = fromLabel @column `As` Alias @column
311+ fromLabel = fromLabel @col `As` Alias
313− ( HasUnique table from columns
313+ ( HasUnique tab from row
314− , Has column columns ty
314+ , Has col row ty
315− , GroupedBy table column bys
315+ , GroupedBy tab col bys
316+ , columns ~ '[col ::: ty]
316− ) => IsLabel column
317+ ) => IsLabel col
317− ( NP (Aliased (Expression db from ('Grouped bys) params))
318+ (NP (Aliased (Expression db params ('Grouped bys) from)) columns) where
318− '[column ::: ty] ) where
319− fromLabel = fromLabel @column :* Nil
319+ fromLabel = fromLabel @col :* Nil
322− ( Has table from columns
322+ ( Has tab from row
323− , Has column columns ty
323+ , Has col row ty
324− , GroupedBy table column bys
324+ , GroupedBy tab col bys
325− ) => IsQualified table column
325+ ) => IsQualified tab col
326− (Expression db from ('Grouped bys) params ty) where
326+ (Expression db params ('Grouped bys) from ty) where
327− table ! column = UnsafeExpression $
327+ tab ! col = UnsafeExpression $
328− renderAlias table <> "." <> renderAlias column
328+ renderSQL tab <> "." <> renderSQL col
330− ( Has table from columns
330+ ( Has tab from row
331− , Has column columns ty
331+ , Has col row ty
332− , GroupedBy table column bys
332+ , GroupedBy tab col bys
333+ , column ~ (col ::: ty)
333− ) => IsQualified table column
334+ ) => IsQualified tab col
334− (Aliased (Expression db from ('Grouped bys) params)
335+ (Aliased (Expression db params ('Grouped bys) from) column) where
335− (column ::: ty)) where
336+ tab ! col = tab ! col `As` col
336− table ! column = table ! column `As` column
338− ( Has table from columns
338+ ( Has tab from row
339− , Has column columns ty
339+ , Has col row ty
340− , GroupedBy table column bys
340+ , GroupedBy tab col bys
341+ , columns ~ '[col ::: ty]
341− ) => IsQualified table column
342+ ) => IsQualified tab col
342− ( NP (Aliased (Expression db from ('Grouped bys) params))
343+ (NP (Aliased (Expression db params ('Grouped bys) from)) columns) where
343− '[column ::: ty]) where
344+ tab ! col = tab ! col :* Nil
344− table ! column = table ! column :* Nil
346-- | analagous to `Nothing`
346-- | analagous to `Nothing`
@@ -357,102 +357,102 @@ null_ = UnsafeExpression "NULL"
358 :: Expression db rels grouping params ('NotNull ty)
358 :: Expression db rels grouping params ('NotNull ty)
359 -> Expression db rels grouping params ('Null ty)
359 -> Expression db rels grouping params ('Null ty)
360−notNull = UnsafeExpression . renderExpression
360+notNull = UnsafeExpression . renderSQL
362-- | return the leftmost value which is not NULL
362-- | return the leftmost value which is not NULL
364-- >>> printSQL $ coalesce [null_, true] false
364-- >>> printSQL $ coalesce [null_, true] false
365-- COALESCE(NULL, TRUE, FALSE)
365-- COALESCE(NULL, TRUE, FALSE)
367− :: [Expression db from grouping params ('Null ty)]
367+ :: [Expression db params grp from ('Null ty)]
368 -- ^ @NULL@s may be present
368 -- ^ @NULL@s may be present
369− -> Expression db from grouping params ('NotNull ty)
369+ -> Expression db params grp from ('NotNull ty)
370 -- ^ @NULL@ is absent
370 -- ^ @NULL@ is absent
371− -> Expression db from grouping params ('NotNull ty)
371+ -> Expression db params grp from ('NotNull ty)
372coalesce nullxs notNullx = UnsafeExpression $
372coalesce nullxs notNullx = UnsafeExpression $
373 "COALESCE" <> parenthesized (commaSeparated
373 "COALESCE" <> parenthesized (commaSeparated
374− ((renderExpression <$> nullxs) <> [renderExpression notNullx]))
374+ ((renderSQL <$> nullxs) <> [renderSQL notNullx]))
376-- | analagous to `Data.Maybe.fromMaybe` using @COALESCE@
376-- | analagous to `Data.Maybe.fromMaybe` using @COALESCE@
378-- >>> printSQL $ fromNull true null_
378-- >>> printSQL $ fromNull true null_
379-- COALESCE(NULL, TRUE)
379-- COALESCE(NULL, TRUE)
381− :: Expression db from grouping params ('NotNull ty)
381+ :: Expression db params grp from ('NotNull ty)
382 -- ^ what to convert @NULL@ to
382 -- ^ what to convert @NULL@ to
383− -> Expression db from grouping params ('Null ty)
383+ -> Expression db params grp from ('Null ty)
384− -> Expression db from grouping params ('NotNull ty)
384+ -> Expression db params grp from ('NotNull ty)
385fromNull notNullx nullx = coalesce [nullx] notNullx
385fromNull notNullx nullx = coalesce [nullx] notNullx
387-- | >>> printSQL $ null_ & isNull
387-- | >>> printSQL $ null_ & isNull
388-- NULL IS NULL
388-- NULL IS NULL
390− :: Expression db from grouping params ('Null ty)
390+ :: Expression db params grp from ('Null ty)
391 -- ^ possibly @NULL@
391 -- ^ possibly @NULL@
392− -> Condition db from grouping params
392+ -> Condition db params grp from
393−isNull x = UnsafeExpression $ renderExpression x <+> "IS NULL"
393+isNull x = UnsafeExpression $ renderSQL x <+> "IS NULL"
395-- | >>> printSQL $ null_ & isNotNull
395-- | >>> printSQL $ null_ & isNotNull
396-- NULL IS NOT NULL
396-- NULL IS NOT NULL
398− :: Expression db from grouping params ('Null ty)
398+ :: Expression db params grp from ('Null ty)
399 -- ^ possibly @NULL@
399 -- ^ possibly @NULL@
400− -> Condition db from grouping params
400+ -> Condition db params grp from
401−isNotNull x = UnsafeExpression $ renderExpression x <+> "IS NOT NULL"
401+isNotNull x = UnsafeExpression $ renderSQL x <+> "IS NOT NULL"
403-- | analagous to `maybe` using @IS NULL@
403-- | analagous to `maybe` using @IS NULL@
405-- >>> printSQL $ matchNull true not_ null_
405-- >>> printSQL $ matchNull true not_ null_
406-- CASE WHEN NULL IS NULL THEN TRUE ELSE (NOT NULL) END
406-- CASE WHEN NULL IS NULL THEN TRUE ELSE (NOT NULL) END
408− :: Expression db from grouping params (nullty)
408+ :: Expression db params grp from (nullty)
409 -- ^ what to convert @NULL@ to
409 -- ^ what to convert @NULL@ to
410− -> ( Expression db from grouping params ('NotNull ty)
410+ -> ( Expression db params grp from ('NotNull ty)
411− -> Expression db from grouping params (nullty) )
411+ -> Expression db params grp from (nullty) )
412 -- ^ function to perform when @NULL@ is absent
412 -- ^ function to perform when @NULL@ is absent
413− -> Expression db from grouping params ('Null ty)
413+ -> Expression db params grp from ('Null ty)
414− -> Expression db from grouping params (nullty)
414+ -> Expression db params grp from (nullty)
415matchNull y f x = ifThenElse (isNull x) y
415matchNull y f x = ifThenElse (isNull x) y
416− (f (UnsafeExpression (renderExpression x)))
416+ (f (UnsafeExpression (renderSQL x)))
418{-| right inverse to `fromNull`, if its arguments are equal then
418{-| right inverse to `fromNull`, if its arguments are equal then
419`nullIf` gives @NULL@.
419`nullIf` gives @NULL@.
421>>> :set -XTypeApplications -XDataKinds
421>>> :set -XTypeApplications -XDataKinds
422−>>> let expr = nullIf false (param @1) :: Expression (commons :=> schema) from grp '[ 'NotNull 'PGbool] ('Null 'PGbool)
422+>>> let expr = nullIf false (param @1) :: Expression (commons :=> schema) '[ 'NotNull 'PGbool] grp from ('Null 'PGbool)
423>>> printSQL expr
423>>> printSQL expr
424NULL IF (FALSE, ($1 :: bool))
424NULL IF (FALSE, ($1 :: bool))
427− :: Expression db from grouping params ('NotNull ty)
427+ :: Expression db params grp from ('NotNull ty)
428 -- ^ @NULL@ is absent
428 -- ^ @NULL@ is absent
429− -> Expression db from grouping params ('NotNull ty)
429+ -> Expression db params grp from ('NotNull ty)
430 -- ^ @NULL@ is absent
430 -- ^ @NULL@ is absent
431− -> Expression db from grouping params ('Null ty)
431+ -> Expression db params grp from ('Null ty)
432nullIf x y = UnsafeExpression $ "NULL IF" <+> parenthesized
432nullIf x y = UnsafeExpression $ "NULL IF" <+> parenthesized
433− (renderExpression x <> ", " <> renderExpression y)
433+ (renderSQL x <> ", " <> renderSQL y)
435-- | >>> printSQL $ array [null_, false, true]
435-- | >>> printSQL $ array [null_, false, true]
436-- ARRAY[NULL, FALSE, TRUE]
436-- ARRAY[NULL, FALSE, TRUE]
438− :: [Expression db from grouping params ty]
438+ :: [Expression db params grp from ty]
439 -- ^ array elements
439 -- ^ array elements
440− -> Expression db from grouping params (nullity ('PGvararray ty))
440+ -> Expression db params grp from (nullity ('PGvararray ty))
441array xs = UnsafeExpression $
441array xs = UnsafeExpression $
442− "ARRAY[" <> commaSeparated (renderExpression <$> xs) <> "]"
442+ "ARRAY[" <> commaSeparated (renderSQL <$> xs) <> "]"
444-- | >>> printSQL $ array [null_, false, true] & index 2
444-- | >>> printSQL $ array [null_, false, true] & index 2
445-- (ARRAY[NULL, FALSE, TRUE])[2]
445-- (ARRAY[NULL, FALSE, TRUE])[2]
447 :: Word64 -- ^ index
447 :: Word64 -- ^ index
448− -> Expression db from grouping params (nullity ('PGvararray ty)) -- ^ array
448+ -> Expression db params grp from (nullity ('PGvararray ty)) -- ^ array
449− -> Expression db from grouping params (NullifyType ty)
449+ -> Expression db params grp from (NullifyType ty)
450index n expr = UnsafeExpression $
450index n expr = UnsafeExpression $
451− parenthesized (renderExpression expr) <> "[" <> fromString (show n) <> "]"
451+ parenthesized (renderSQL expr) <> "[" <> fromString (show n) <> "]"
453instance (KnownSymbol label, label `In` labels) => IsPGlabel label
453instance (KnownSymbol label, label `In` labels) => IsPGlabel label
454− (Expression db from grouping params (nullity ('PGenum labels))) where
454+ (Expression db params grp from (nullity ('PGenum labels))) where
455− label = UnsafeExpression $ renderLabel (PGlabel @label)
455+ label = UnsafeExpression $ renderSQL (PGlabel @label)
457-- | A row constructor is an expression that builds a row value
457-- | A row constructor is an expression that builds a row value
458-- (also called a composite value) using values for its member fields.
458-- (also called a composite value) using values for its member fields.
@@ -468,11 +468,11 @@ instance (KnownSymbol label, label `In` labels) => IsPGlabel label
468-- ROW(0, 1)
468-- ROW(0, 1)
470 :: SListI row
470 :: SListI row
471− => NP (Aliased (Expression db from grouping params)) row
471+ => NP (Aliased (Expression db params grp from)) row
472 -- ^ zero or more expressions for the row field values
472 -- ^ zero or more expressions for the row field values
473− -> Expression db from grouping params (nullity ('PGcomposite row))
473+ -> Expression db params grp from (nullity ('PGcomposite row))
474row exprs = UnsafeExpression $ "ROW" <> parenthesized
474row exprs = UnsafeExpression $ "ROW" <> parenthesized
475− (renderCommaSeparated (\ (expr `As` _) -> renderExpression expr) exprs)
475+ (renderCommaSeparated (\ (expr `As` _) -> renderSQL expr) exprs)
477-- | >>> :{
477-- | >>> :{
478-- type Complex = 'PGcomposite
478-- type Complex = 'PGcomposite
@@ -491,87 +491,87 @@ field
491 , Has field row ty)
491 , Has field row ty)
492 => QualifiedAlias sch tydef -- ^ row type
492 => QualifiedAlias sch tydef -- ^ row type
493 -> Alias field -- ^ field name
493 -> Alias field -- ^ field name
494− -> Expression (commons :=> schemas) from grouping params ('NotNull ('PGcomposite row))
494+ -> Expression (commons :=> schemas) params grp from ('NotNull ('PGcomposite row))
495− -> Expression (commons :=> schemas) from grouping params ty
495+ -> Expression (commons :=> schemas) params grp from ty
496field td fld expr = UnsafeExpression $
496field td fld expr = UnsafeExpression $
497− parenthesized (renderExpression expr <> "::" <> renderQualifiedAlias td)
497+ parenthesized (renderSQL expr <> "::" <> renderSQL td)
498− <> "." <> renderAlias fld
498+ <> "." <> renderSQL fld
500instance Semigroup
500instance Semigroup
501− (Expression db from grouping params (nullity ('PGvararray ty))) where
501+ (Expression db params grp from (nullity ('PGvararray ty))) where
502 (<>) = unsafeBinaryOp "||"
502 (<>) = unsafeBinaryOp "||"
504instance Monoid
504instance Monoid
505− (Expression db from grouping params (nullity ('PGvararray ty))) where
505+ (Expression db params grp from (nullity ('PGvararray ty))) where
506 mempty = array []
506 mempty = array []
507 mappend = (<>)
507 mappend = (<>)
509−-- | >>> let expr = greatest currentTimestamp [param @1] :: Expression (commons :=> schemas) rels grp '[ 'NotNull 'PGtimestamptz] ('NotNull 'PGtimestamptz)
509+-- | >>> let expr = greatest currentTimestamp [param @1] :: Expression (commons :=> schemas) '[ 'NotNull 'PGtimestamptz] grp from ('NotNull 'PGtimestamptz)
510-- >>> printSQL expr
510-- >>> printSQL expr
511-- GREATEST(CURRENT_TIMESTAMP, ($1 :: timestamp with time zone))
511-- GREATEST(CURRENT_TIMESTAMP, ($1 :: timestamp with time zone))
513− :: Expression db from grouping params (nullty)
513+ :: Expression db params grp from (nullty)
514 -- ^ needs at least 1 argument
514 -- ^ needs at least 1 argument
515− -> [Expression db from grouping params (nullty)]
515+ -> [Expression db params grp from (nullty)]
516 -- ^ or more
516 -- ^ or more
517− -> Expression db from grouping params (nullty)
517+ -> Expression db params grp from (nullty)
518greatest x xs = UnsafeExpression $ "GREATEST("
518greatest x xs = UnsafeExpression $ "GREATEST("
519− <> commaSeparated (renderExpression <$> (x:xs)) <> ")"
519+ <> commaSeparated (renderSQL <$> (x:xs)) <> ")"
521-- | >>> printSQL $ least currentTimestamp [null_]
521-- | >>> printSQL $ least currentTimestamp [null_]
522-- LEAST(CURRENT_TIMESTAMP, NULL)
522-- LEAST(CURRENT_TIMESTAMP, NULL)
524− :: Expression db from grouping params (nullty)
524+ :: Expression db params grp from (nullty)
525 -- ^ needs at least 1 argument
525 -- ^ needs at least 1 argument
526− -> [Expression db from grouping params (nullty)]
526+ -> [Expression db params grp from (nullty)]
527 -- ^ or more
527 -- ^ or more
528− -> Expression db from grouping params (nullty)
528+ -> Expression db params grp from (nullty)
529least x xs = UnsafeExpression $ "LEAST("
529least x xs = UnsafeExpression $ "LEAST("
530− <> commaSeparated (renderExpression <$> (x:xs)) <> ")"
530+ <> commaSeparated (renderSQL <$> (x:xs)) <> ")"
532-- | >>> printSQL $ unsafeBinaryOp "OR" true false
532-- | >>> printSQL $ unsafeBinaryOp "OR" true false
533-- (TRUE OR FALSE)
533-- (TRUE OR FALSE)
534unsafeBinaryOp
534unsafeBinaryOp
535 :: ByteString
535 :: ByteString
536 -- ^ operator
536 -- ^ operator
537− -> Expression db from grouping params (ty0)
537+ -> Expression db params grp from (ty0)
538− -> Expression db from grouping params (ty1)
538+ -> Expression db params grp from (ty1)
539− -> Expression db from grouping params (ty2)
539+ -> Expression db params grp from (ty2)
540unsafeBinaryOp op x y = UnsafeExpression $ parenthesized $
540unsafeBinaryOp op x y = UnsafeExpression $ parenthesized $
541− renderExpression x <+> op <+> renderExpression y
541+ renderSQL x <+> op <+> renderSQL y
543-- | >>> printSQL $ unsafeUnaryOp "NOT" true
543-- | >>> printSQL $ unsafeUnaryOp "NOT" true
544-- (NOT TRUE)
544-- (NOT TRUE)
545unsafeUnaryOp
545unsafeUnaryOp
546 :: ByteString
546 :: ByteString
547 -- ^ operator
547 -- ^ operator
548− -> Expression db from grouping params (ty0)
548+ -> Expression db params grp from (ty0)
549− -> Expression db from grouping params (ty1)
549+ -> Expression db params grp from (ty1)
550unsafeUnaryOp op x = UnsafeExpression $ parenthesized $
550unsafeUnaryOp op x = UnsafeExpression $ parenthesized $
551− op <+> renderExpression x
551+ op <+> renderSQL x
553-- | >>> printSQL $ unsafeFunction "f" true
553-- | >>> printSQL $ unsafeFunction "f" true
554-- f(TRUE)
554-- f(TRUE)
555unsafeFunction
555unsafeFunction
556 :: ByteString
556 :: ByteString
557 -- ^ function
557 -- ^ function
558− -> Expression db from grouping params (xty)
558+ -> Expression db params grp from (xty)
559− -> Expression db from grouping params (yty)
559+ -> Expression db params grp from (yty)
560unsafeFunction fun x = UnsafeExpression $
560unsafeFunction fun x = UnsafeExpression $
561− fun <> parenthesized (renderExpression x)
561+ fun <> parenthesized (renderSQL x)
563-- | Helper for defining variadic functions.
563-- | Helper for defining variadic functions.
564unsafeVariadicFunction
564unsafeVariadicFunction
565 :: SListI elems
565 :: SListI elems
566 => ByteString
566 => ByteString
567 -- ^ function
567 -- ^ function
568− -> NP (Expression db from grouping params) elems
568+ -> NP (Expression db params grp from) elems
569− -> Expression db from grouping params ret
569+ -> Expression db params grp from ret
570unsafeVariadicFunction fun x = UnsafeExpression $
570unsafeVariadicFunction fun x = UnsafeExpression $
571− fun <> parenthesized (commaSeparated (hcollapse (hmap (K . renderExpression) x)))
571+ fun <> parenthesized (commaSeparated (hcollapse (hmap (K . renderSQL) x)))
573instance ty `In` PGNum
573instance ty `In` PGNum
574− => Num (Expression db from grouping params (nullity ty)) where
574+ => Num (Expression db params grp from (nullity ty)) where
575 (+) = unsafeBinaryOp "+"
575 (+) = unsafeBinaryOp "+"
576 (-) = unsafeBinaryOp "-"
576 (-) = unsafeBinaryOp "-"
577 (*) = unsafeBinaryOp "*"
577 (*) = unsafeBinaryOp "*"
@@ -583,18 +583,18 @@ instance ty `In` PGNum
585instance (ty `In` PGNum, ty `In` PGFloating) => Fractional
585instance (ty `In` PGNum, ty `In` PGFloating) => Fractional
586− (Expression db from grouping params (nullity ty)) where
586+ (Expression db params grp from (nullity ty)) where
587 (/) = unsafeBinaryOp "/"
587 (/) = unsafeBinaryOp "/"
588 fromRational x = fromInteger (numerator x) / fromInteger (denominator x)
588 fromRational x = fromInteger (numerator x) / fromInteger (denominator x)
590instance (ty `In` PGNum, ty `In` PGFloating) => Floating
590instance (ty `In` PGNum, ty `In` PGFloating) => Floating
591− (Expression db from grouping params (nullity ty)) where
591+ (Expression db params grp from (nullity ty)) where
592 pi = UnsafeExpression "pi()"
592 pi = UnsafeExpression "pi()"
593 exp = unsafeFunction "exp"
593 exp = unsafeFunction "exp"
594 log = unsafeFunction "ln"
594 log = unsafeFunction "ln"
595 sqrt = unsafeFunction "sqrt"
595 sqrt = unsafeFunction "sqrt"
596 b ** x = UnsafeExpression $
596 b ** x = UnsafeExpression $
597− "power(" <> renderExpression b <> ", " <> renderExpression x <> ")"
597+ "power(" <> renderSQL b <> ", " <> renderSQL x <> ")"
598 logBase b y = log y / log b
598 logBase b y = log y / log b
599 sin = unsafeFunction "sin"
599 sin = unsafeFunction "sin"
600 cos = unsafeFunction "cos"
600 cos = unsafeFunction "cos"
@@ -611,20 +611,20 @@ instance (ty `In` PGNum, ty `In` PGFloating) => Floating
612-- | >>> :{
612-- | >>> :{
614−-- expression :: Expression db from grouping params (nullity 'PGfloat4)
614+-- expression :: Expression db params grp from (nullity 'PGfloat4)
615-- expression = atan2_ pi 2
615-- expression = atan2_ pi 2
616-- in printSQL expression
616-- in printSQL expression
618-- atan2(pi(), 2)
618-- atan2(pi(), 2)
620 :: float `In` PGFloating
620 :: float `In` PGFloating
621− => Expression db from grouping params (nullity float)
621+ => Expression db params grp from (nullity float)
622 -- ^ numerator
622 -- ^ numerator
623− -> Expression db from grouping params (nullity float)
623+ -> Expression db params grp from (nullity float)
624 -- ^ denominator
624 -- ^ denominator
625− -> Expression db from grouping params (nullity float)
625+ -> Expression db params grp from (nullity float)
626atan2_ y x = UnsafeExpression $
626atan2_ y x = UnsafeExpression $
627− "atan2(" <> renderExpression y <> ", " <> renderExpression x <> ")"
627+ "atan2(" <> renderSQL y <> ", " <> renderSQL x <> ")"
629-- When a `cast` is applied to an `Expression` of a known type, it
629-- When a `cast` is applied to an `Expression` of a known type, it
630-- represents a run-time type conversion. The cast will succeed only if a
630-- represents a run-time type conversion. The cast will succeed only if a
@@ -635,171 +635,171 @@ atan2_ y x = UnsafeExpression $
636 :: TypeExpression schemas ty1
636 :: TypeExpression schemas ty1
637 -- ^ type to cast as
637 -- ^ type to cast as
638− -> Expression (commons :=> schemas) from grouping params ty0
638+ -> Expression (commons :=> schemas) params grp from ty0
639 -- ^ value to convert
639 -- ^ value to convert
640− -> Expression (commons :=> schemas) from grouping params ty1
640+ -> Expression (commons :=> schemas) params grp from ty1
641cast ty x = UnsafeExpression $ parenthesized $
641cast ty x = UnsafeExpression $ parenthesized $
642− renderExpression x <+> "::" <+> renderTypeExpression ty
642+ renderSQL x <+> "::" <+> renderSQL ty
644-- | integer division, truncates the result
644-- | integer division, truncates the result
648−-- expression :: Expression db from grouping params (nullity 'PGint2)
648+-- expression :: Expression db params grp from (nullity 'PGint2)
649-- expression = 5 `quot_` 2
649-- expression = 5 `quot_` 2
650-- in printSQL expression
650-- in printSQL expression
652-- (5 / 2)
652-- (5 / 2)
654 :: int `In` PGIntegral
654 :: int `In` PGIntegral
655− => Expression db from grouping params (nullity int)
655+ => Expression db params grp from (nullity int)
656 -- ^ numerator
656 -- ^ numerator
657− -> Expression db from grouping params (nullity int)
657+ -> Expression db params grp from (nullity int)
658 -- ^ denominator
658 -- ^ denominator
659− -> Expression db from grouping params (nullity int)
659+ -> Expression db params grp from (nullity int)
660quot_ = unsafeBinaryOp "/"
660quot_ = unsafeBinaryOp "/"
662-- | remainder upon integer division
662-- | remainder upon integer division
666−-- expression :: Expression db from grouping params (nullity 'PGint2)
666+-- expression :: Expression db params grp from (nullity 'PGint2)
667-- expression = 5 `rem_` 2
667-- expression = 5 `rem_` 2
668-- in printSQL expression
668-- in printSQL expression
670-- (5 % 2)
670-- (5 % 2)
672 :: int `In` PGIntegral
672 :: int `In` PGIntegral
673− => Expression db from grouping params (nullity int)
673+ => Expression db params grp from (nullity int)
674 -- ^ numerator
674 -- ^ numerator
675− -> Expression db from grouping params (nullity int)
675+ -> Expression db params grp from (nullity int)
676 -- ^ denominator
676 -- ^ denominator
677− -> Expression db from grouping params (nullity int)
677+ -> Expression db params grp from (nullity int)
678rem_ = unsafeBinaryOp "%"
678rem_ = unsafeBinaryOp "%"
680-- | >>> :{
680-- | >>> :{
682−-- expression :: Expression db from grouping params (nullity 'PGfloat4)
682+-- expression :: Expression db params grp from (nullity 'PGfloat4)
683-- expression = trunc pi
683-- expression = trunc pi
684-- in printSQL expression
684-- in printSQL expression
686-- trunc(pi())
686-- trunc(pi())
688 :: frac `In` PGFloating
688 :: frac `In` PGFloating
689− => Expression db from grouping params (nullity frac)
689+ => Expression db params grp from (nullity frac)
690 -- ^ fractional number
690 -- ^ fractional number
691− -> Expression db from grouping params (nullity frac)
691+ -> Expression db params grp from (nullity frac)
692trunc = unsafeFunction "trunc"
692trunc = unsafeFunction "trunc"
694-- | >>> :{
694-- | >>> :{
696−-- expression :: Expression db from grouping params (nullity 'PGfloat4)
696+-- expression :: Expression db params grp from (nullity 'PGfloat4)
697-- expression = round_ pi
697-- expression = round_ pi
698-- in printSQL expression
698-- in printSQL expression
700-- round(pi())
700-- round(pi())
702 :: frac `In` PGFloating
702 :: frac `In` PGFloating
703− => Expression db from grouping params (nullity frac)
703+ => Expression db params grp from (nullity frac)
704 -- ^ fractional number
704 -- ^ fractional number
705− -> Expression db from grouping params (nullity frac)
705+ -> Expression db params grp from (nullity frac)
706round_ = unsafeFunction "round"
706round_ = unsafeFunction "round"
708-- | >>> :{
708-- | >>> :{
710−-- expression :: Expression db from grouping params (nullity 'PGfloat4)
710+-- expression :: Expression db params grp from (nullity 'PGfloat4)
711-- expression = ceiling_ pi
711-- expression = ceiling_ pi
712-- in printSQL expression
712-- in printSQL expression
714-- ceiling(pi())
714-- ceiling(pi())
716 :: frac `In` PGFloating
716 :: frac `In` PGFloating
717− => Expression db from grouping params (nullity frac)
717+ => Expression db params grp from (nullity frac)
718 -- ^ fractional number
718 -- ^ fractional number
719− -> Expression db from grouping params (nullity frac)
719+ -> Expression db params grp from (nullity frac)
720ceiling_ = unsafeFunction "ceiling"
720ceiling_ = unsafeFunction "ceiling"
722-- | A `Condition` is an `Expression`, which can evaluate
722-- | A `Condition` is an `Expression`, which can evaluate
723-- to `true`, `false` or `null_`. This is because SQL uses
723-- to `true`, `false` or `null_`. This is because SQL uses
724-- a three valued logic.
724-- a three valued logic.
725−type Condition db from grouping params =
725+type Condition db params grp from =
726− Expression db from grouping params ('Null 'PGbool)
726+ Expression db params grp from ('Null 'PGbool)
728-- | >>> printSQL true
728-- | >>> printSQL true
730−true :: Expression db from grouping params (nullity 'PGbool)
730+true :: Expression db params grp from (nullity 'PGbool)
731true = UnsafeExpression "TRUE"
731true = UnsafeExpression "TRUE"
733-- | >>> printSQL false
733-- | >>> printSQL false
735−false :: Expression db from grouping params (nullity 'PGbool)
735+false :: Expression db params grp from (nullity 'PGbool)
736false = UnsafeExpression "FALSE"
736false = UnsafeExpression "FALSE"
738-- | >>> printSQL $ not_ true
738-- | >>> printSQL $ not_ true
739-- (NOT TRUE)
739-- (NOT TRUE)
741− :: Expression db from grouping params (nullity 'PGbool)
741+ :: Expression db params grp from (nullity 'PGbool)
742− -> Expression db from grouping params (nullity 'PGbool)
742+ -> Expression db params grp from (nullity 'PGbool)
743not_ = unsafeUnaryOp "NOT"
743not_ = unsafeUnaryOp "NOT"
745-- | >>> printSQL $ true .&& false
745-- | >>> printSQL $ true .&& false
746-- (TRUE AND FALSE)
746-- (TRUE AND FALSE)
748− :: Expression db from grouping params (nullity 'PGbool)
748+ :: Expression db params grp from (nullity 'PGbool)
749− -> Expression db from grouping params (nullity 'PGbool)
749+ -> Expression db params grp from (nullity 'PGbool)
750− -> Expression db from grouping params (nullity 'PGbool)
750+ -> Expression db params grp from (nullity 'PGbool)
751infixr 3 .&&
751infixr 3 .&&
752(.&&) = unsafeBinaryOp "AND"
752(.&&) = unsafeBinaryOp "AND"
754-- | >>> printSQL $ true .|| false
754-- | >>> printSQL $ true .|| false
755-- (TRUE OR FALSE)
755-- (TRUE OR FALSE)
757− :: Expression db from grouping params (nullity 'PGbool)
757+ :: Expression db params grp from (nullity 'PGbool)
758− -> Expression db from grouping params (nullity 'PGbool)
758+ -> Expression db params grp from (nullity 'PGbool)
759− -> Expression db from grouping params (nullity 'PGbool)
759+ -> Expression db params grp from (nullity 'PGbool)
760infixr 2 .||
760infixr 2 .||
761(.||) = unsafeBinaryOp "OR"
761(.||) = unsafeBinaryOp "OR"
763-- | >>> :{
763-- | >>> :{
765−-- expression :: Expression db from grouping params (nullity 'PGint2)
765+-- expression :: Expression db params grp from (nullity 'PGint2)
766-- expression = caseWhenThenElse [(true, 1), (false, 2)] 3
766-- expression = caseWhenThenElse [(true, 1), (false, 2)] 3
767-- in printSQL expression
767-- in printSQL expression
769-- CASE WHEN TRUE THEN 1 WHEN FALSE THEN 2 ELSE 3 END
769-- CASE WHEN TRUE THEN 1 WHEN FALSE THEN 2 ELSE 3 END
770caseWhenThenElse
770caseWhenThenElse
771− :: [ ( Condition db from grouping params
771+ :: [ ( Condition db params grp from
772− , Expression db from grouping params ty
772+ , Expression db params grp from ty
774 -- ^ whens and thens
774 -- ^ whens and thens
775− -> Expression db from grouping params ty
775+ -> Expression db params grp from ty
776 -- ^ else
776 -- ^ else
777− -> Expression db from grouping params ty
777+ -> Expression db params grp from ty
778caseWhenThenElse whenThens else_ = UnsafeExpression $ mconcat
778caseWhenThenElse whenThens else_ = UnsafeExpression $ mconcat
780 , mconcat
780 , mconcat
781 [ mconcat
781 [ mconcat
782− [ " WHEN ", renderExpression when_
782+ [ " WHEN ", renderSQL when_
783− , " THEN ", renderExpression then_
783+ , " THEN ", renderSQL then_
785 | (when_,then_) <- whenThens
785 | (when_,then_) <- whenThens
787− , " ELSE ", renderExpression else_
787+ , " ELSE ", renderSQL else_
791-- | >>> :{
791-- | >>> :{
793−-- expression :: Expression db from grouping params (nullity 'PGint2)
793+-- expression :: Expression db params grp from (nullity 'PGint2)
794-- expression = ifThenElse true 1 0
794-- expression = ifThenElse true 1 0
795-- in printSQL expression
795-- in printSQL expression
797-- CASE WHEN TRUE THEN 1 ELSE 0 END
797-- CASE WHEN TRUE THEN 1 ELSE 0 END
798ifThenElse
798ifThenElse
799− :: Condition db from grouping params
799+ :: Condition db params grp from
800− -> Expression db from grouping params ty -- ^ then
800+ -> Expression db params grp from ty -- ^ then
801− -> Expression db from grouping params ty -- ^ else
801+ -> Expression db params grp from ty -- ^ else
802− -> Expression db from grouping params ty
802+ -> Expression db params grp from ty
803ifThenElse if_ then_ else_ = caseWhenThenElse [(if_,then_)] else_
803ifThenElse if_ then_ else_ = caseWhenThenElse [(if_,then_)] else_
805-- | Comparison operations like `.==`, `./=`, `.>`, `.>=`, `.<` and `.<=`
805-- | Comparison operations like `.==`, `./=`, `.>`, `.>=`, `.<` and `.<=`
@@ -808,85 +808,85 @@ ifThenElse if_ then_ else_ = caseWhenThenElse [(if_,then_)] else_
808-- >>> printSQL $ true .== null_
808-- >>> printSQL $ true .== null_
809-- (TRUE = NULL)
809-- (TRUE = NULL)
811− :: Expression db from grouping params (nullity0 ty) -- ^ lhs
811+ :: Expression db params grp from (nullity0 ty) -- ^ lhs
812− -> Expression db from grouping params (nullity1 ty) -- ^ rhs
812+ -> Expression db params grp from (nullity1 ty) -- ^ rhs
813− -> Condition db from grouping params
813+ -> Condition db params grp from
814(.==) = unsafeBinaryOp "="
814(.==) = unsafeBinaryOp "="
815infix 4 .==
815infix 4 .==
817-- | >>> printSQL $ true ./= null_
817-- | >>> printSQL $ true ./= null_
818-- (TRUE <> NULL)
818-- (TRUE <> NULL)
820− :: Expression db from grouping params (nullity0 ty) -- ^ lhs
820+ :: Expression db params grp from (nullity0 ty) -- ^ lhs
821− -> Expression db from grouping params (nullity1 ty) -- ^ rhs
821+ -> Expression db params grp from (nullity1 ty) -- ^ rhs
822− -> Condition db from grouping params
822+ -> Condition db params grp from
823(./=) = unsafeBinaryOp "<>"
823(./=) = unsafeBinaryOp "<>"
824infix 4 ./=
824infix 4 ./=
826-- | >>> printSQL $ true .>= null_
826-- | >>> printSQL $ true .>= null_
827-- (TRUE >= NULL)
827-- (TRUE >= NULL)
829− :: Expression db from grouping params (nullity0 ty) -- ^ lhs
829+ :: Expression db params grp from (nullity0 ty) -- ^ lhs
830− -> Expression db from grouping params (nullity1 ty) -- ^ rhs
830+ -> Expression db params grp from (nullity1 ty) -- ^ rhs
831− -> Condition db from grouping params
831+ -> Condition db params grp from
832(.>=) = unsafeBinaryOp ">="
832(.>=) = unsafeBinaryOp ">="
833infix 4 .>=
833infix 4 .>=
835-- | >>> printSQL $ true .< null_
835-- | >>> printSQL $ true .< null_
836-- (TRUE < NULL)
836-- (TRUE < NULL)
838− :: Expression db from grouping params (nullity0 ty) -- ^ lhs
838+ :: Expression db params grp from (nullity0 ty) -- ^ lhs
839− -> Expression db from grouping params (nullity1 ty) -- ^ rhs
839+ -> Expression db params grp from (nullity1 ty) -- ^ rhs
840− -> Condition db from grouping params
840+ -> Condition db params grp from
841(.<) = unsafeBinaryOp "<"
841(.<) = unsafeBinaryOp "<"
842infix 4 .<
842infix 4 .<
844-- | >>> printSQL $ true .<= null_
844-- | >>> printSQL $ true .<= null_
845-- (TRUE <= NULL)
845-- (TRUE <= NULL)
847− :: Expression db from grouping params (nullity0 ty) -- ^ lhs
847+ :: Expression db params grp from (nullity0 ty) -- ^ lhs
848− -> Expression db from grouping params (nullity1 ty) -- ^ rhs
848+ -> Expression db params grp from (nullity1 ty) -- ^ rhs
849− -> Condition db from grouping params
849+ -> Condition db params grp from
850(.<=) = unsafeBinaryOp "<="
850(.<=) = unsafeBinaryOp "<="
851infix 4 .<=
851infix 4 .<=
853-- | >>> printSQL $ true .> null_
853-- | >>> printSQL $ true .> null_
854-- (TRUE > NULL)
854-- (TRUE > NULL)
856− :: Expression db from grouping params (nullity0 ty) -- ^ lhs
856+ :: Expression db params grp from (nullity0 ty) -- ^ lhs
857− -> Expression db from grouping params (nullity1 ty) -- ^ rhs
857+ -> Expression db params grp from (nullity1 ty) -- ^ rhs
858− -> Condition db from grouping params
858+ -> Condition db params grp from
859(.>) = unsafeBinaryOp ">"
859(.>) = unsafeBinaryOp ">"
860infix 4 .>
860infix 4 .>
862-- | >>> printSQL currentDate
862-- | >>> printSQL currentDate
863-- CURRENT_DATE
863-- CURRENT_DATE
864currentDate
864currentDate
865− :: Expression db from grouping params (nullity 'PGdate)
865+ :: Expression db params grp from (nullity 'PGdate)
866currentDate = UnsafeExpression "CURRENT_DATE"
866currentDate = UnsafeExpression "CURRENT_DATE"
868-- | >>> printSQL currentTime
868-- | >>> printSQL currentTime
869-- CURRENT_TIME
869-- CURRENT_TIME
870currentTime
870currentTime
871− :: Expression db from grouping params (nullity 'PGtimetz)
871+ :: Expression db params grp from (nullity 'PGtimetz)
872currentTime = UnsafeExpression "CURRENT_TIME"
872currentTime = UnsafeExpression "CURRENT_TIME"
874-- | >>> printSQL currentTimestamp
874-- | >>> printSQL currentTimestamp
875-- CURRENT_TIMESTAMP
875-- CURRENT_TIMESTAMP
876currentTimestamp
876currentTimestamp
877− :: Expression db from grouping params (nullity 'PGtimestamptz)
877+ :: Expression db params grp from (nullity 'PGtimestamptz)
878currentTimestamp = UnsafeExpression "CURRENT_TIMESTAMP"
878currentTimestamp = UnsafeExpression "CURRENT_TIMESTAMP"
880-- | >>> printSQL localTime
880-- | >>> printSQL localTime
881-- LOCALTIME
881-- LOCALTIME
883− :: Expression db from grouping params (nullity 'PGtime)
883+ :: Expression db params grp from (nullity 'PGtime)
884localTime = UnsafeExpression "LOCALTIME"
884localTime = UnsafeExpression "LOCALTIME"
886-- | >>> printSQL localTimestamp
886-- | >>> printSQL localTimestamp
887-- LOCALTIMESTAMP
887-- LOCALTIMESTAMP
888localTimestamp
888localTimestamp
889− :: Expression db from grouping params (nullity 'PGtimestamp)
889+ :: Expression db params grp from (nullity 'PGtimestamp)
890localTimestamp = UnsafeExpression "LOCALTIMESTAMP"
890localTimestamp = UnsafeExpression "LOCALTIMESTAMP"
892{-----------------------------------------
892{-----------------------------------------
@@ -894,7 +894,7 @@ text
894-----------------------------------------}
894-----------------------------------------}
896instance IsString
896instance IsString
897− (Expression db from grouping params (nullity 'PGtext)) where
897+ (Expression db params grp from (nullity 'PGtext)) where
898 fromString str = UnsafeExpression $
898 fromString str = UnsafeExpression $
899 "E\'" <> fromString (escape =<< str) <> "\'"
899 "E\'" <> fromString (escape =<< str) <> "\'"
@@ -910,36 +910,36 @@ instance IsString
912instance Semigroup
912instance Semigroup
913− (Expression db from grouping params (nullity 'PGtext)) where
913+ (Expression db params grp from (nullity 'PGtext)) where
914 (<>) = unsafeBinaryOp "||"
914 (<>) = unsafeBinaryOp "||"
916instance Monoid
916instance Monoid
917− (Expression db from grouping params (nullity 'PGtext)) where
917+ (Expression db params grp from (nullity 'PGtext)) where
918 mempty = fromString ""
918 mempty = fromString ""
919 mappend = (<>)
919 mappend = (<>)
921-- | >>> printSQL $ lower "ARRRGGG"
921-- | >>> printSQL $ lower "ARRRGGG"
922-- lower(E'ARRRGGG')
922-- lower(E'ARRRGGG')
924− :: Expression db from grouping params (nullity 'PGtext)
924+ :: Expression db params grp from (nullity 'PGtext)
925 -- ^ string to lower case
925 -- ^ string to lower case
926− -> Expression db from grouping params (nullity 'PGtext)
926+ -> Expression db params grp from (nullity 'PGtext)
927lower = unsafeFunction "lower"
927lower = unsafeFunction "lower"
929-- | >>> printSQL $ upper "eeee"
929-- | >>> printSQL $ upper "eeee"
930-- upper(E'eeee')
930-- upper(E'eeee')
932− :: Expression db from grouping params (nullity 'PGtext)
932+ :: Expression db params grp from (nullity 'PGtext)
933 -- ^ string to upper case
933 -- ^ string to upper case
934− -> Expression db from grouping params (nullity 'PGtext)
934+ -> Expression db params grp from (nullity 'PGtext)
935upper = unsafeFunction "upper"
935upper = unsafeFunction "upper"
937-- | >>> printSQL $ charLength "four"
937-- | >>> printSQL $ charLength "four"
938-- char_length(E'four')
938-- char_length(E'four')
939charLength
939charLength
940− :: Expression db from grouping params (nullity 'PGtext)
940+ :: Expression db params grp from (nullity 'PGtext)
941 -- ^ string to measure
941 -- ^ string to measure
942− -> Expression db from grouping params (nullity 'PGint4)
942+ -> Expression db params grp from (nullity 'PGint4)
943charLength = unsafeFunction "char_length"
943charLength = unsafeFunction "char_length"
945-- | The `like` expression returns true if the @string@ matches
945-- | The `like` expression returns true if the @string@ matches
@@ -952,11 +952,11 @@ charLength = unsafeFunction "char_length"
952-- >>> printSQL $ "abc" `like` "a%"
952-- >>> printSQL $ "abc" `like` "a%"
953-- (E'abc' LIKE E'a%')
953-- (E'abc' LIKE E'a%')
955− :: Expression db from grouping params (nullity 'PGtext)
955+ :: Expression db params grp from (nullity 'PGtext)
956 -- ^ string
956 -- ^ string
957− -> Expression db from grouping params (nullity 'PGtext)
957+ -> Expression db params grp from (nullity 'PGtext)
958 -- ^ pattern
958 -- ^ pattern
959− -> Expression db from grouping params (nullity 'PGbool)
959+ -> Expression db params grp from (nullity 'PGbool)
960like = unsafeBinaryOp "LIKE"
960like = unsafeBinaryOp "LIKE"
962-- | The key word ILIKE can be used instead of LIKE to make the
962-- | The key word ILIKE can be used instead of LIKE to make the
@@ -965,11 +965,11 @@ like = unsafeBinaryOp "LIKE"
965-- >>> printSQL $ "abc" `ilike` "a%"
965-- >>> printSQL $ "abc" `ilike` "a%"
966-- (E'abc' ILIKE E'a%')
966-- (E'abc' ILIKE E'a%')
968− :: Expression db from grouping params (nullity 'PGtext)
968+ :: Expression db params grp from (nullity 'PGtext)
969 -- ^ string
969 -- ^ string
970− -> Expression db from grouping params (nullity 'PGtext)
970+ -> Expression db params grp from (nullity 'PGtext)
971 -- ^ pattern
971 -- ^ pattern
972− -> Expression db from grouping params (nullity 'PGbool)
972+ -> Expression db params grp from (nullity 'PGbool)
973ilike = unsafeBinaryOp "ILIKE"
973ilike = unsafeBinaryOp "ILIKE"
975{-----------------------------------------
975{-----------------------------------------
@@ -984,36 +984,36 @@ Table 9.44: json and jsonb operators
984-- | Get JSON value (object field or array element) at a key.
984-- | Get JSON value (object field or array element) at a key.
986 :: (json `In` PGJsonType, key `In` PGJsonKey)
986 :: (json `In` PGJsonType, key `In` PGJsonKey)
987− => Expression db from grouping params (nullity json)
987+ => Expression db params grp from (nullity json)
988− -> Expression db from grouping params (nullity key)
988+ -> Expression db params grp from (nullity key)
989− -> Expression db from grouping params ('Null json)
989+ -> Expression db params grp from ('Null json)
990infixl 8 .->
990infixl 8 .->
991(.->) = unsafeBinaryOp "->"
991(.->) = unsafeBinaryOp "->"
993-- | Get JSON value (object field or array element) at a key, as text.
993-- | Get JSON value (object field or array element) at a key, as text.
995 :: (json `In` PGJsonType, key `In` PGJsonKey)
995 :: (json `In` PGJsonType, key `In` PGJsonKey)
996− => Expression db from grouping params (nullity json)
996+ => Expression db params grp from (nullity json)
997− -> Expression db from grouping params (nullity key)
997+ -> Expression db params grp from (nullity key)
998− -> Expression db from grouping params ('Null 'PGtext)
998+ -> Expression db params grp from ('Null 'PGtext)
999infixl 8 .->>
999infixl 8 .->>
1000(.->>) = unsafeBinaryOp "->>"
1000(.->>) = unsafeBinaryOp "->>"
1002-- | Get JSON value at a specified path.
1002-- | Get JSON value at a specified path.
1004 :: (json `In` PGJsonType, PGTextArray "(.#>)" path)
1004 :: (json `In` PGJsonType, PGTextArray "(.#>)" path)
1005− => Expression db from grouping params (nullity json)
1005+ => Expression db params grp from (nullity json)
1006− -> Expression db from grouping params (nullity path)
1006+ -> Expression db params grp from (nullity path)
1007− -> Expression db from grouping params ('Null json)
1007+ -> Expression db params grp from ('Null json)
1008infixl 8 .#>
1008infixl 8 .#>
1009(.#>) = unsafeBinaryOp "#>"
1009(.#>) = unsafeBinaryOp "#>"
1011-- | Get JSON value at a specified path as text.
1011-- | Get JSON value at a specified path as text.
1013 :: (json `In` PGJsonType, PGTextArray "(.#>>)" path)
1013 :: (json `In` PGJsonType, PGTextArray "(.#>>)" path)
1014− => Expression db from grouping params (nullity json)
1014+ => Expression db params grp from (nullity json)
1015− -> Expression db from grouping params (nullity path)
1015+ -> Expression db params grp from (nullity path)
1016− -> Expression db from grouping params ('Null 'PGtext)
1016+ -> Expression db params grp from ('Null 'PGtext)
1017infixl 8 .#>>
1017infixl 8 .#>>
1018(.#>>) = unsafeBinaryOp "#>>"
1018(.#>>) = unsafeBinaryOp "#>>"
@@ -1022,42 +1022,42 @@ infixl 8 .#>>
1022-- | Does the left JSON value contain the right JSON path/value entries at the
1022-- | Does the left JSON value contain the right JSON path/value entries at the
1023-- top level?
1023-- top level?
1025− :: Expression db from grouping params (nullity 'PGjsonb)
1025+ :: Expression db params grp from (nullity 'PGjsonb)
1026− -> Expression db from grouping params (nullity 'PGjsonb)
1026+ -> Expression db params grp from (nullity 'PGjsonb)
1027− -> Condition db from grouping params
1027+ -> Condition db params grp from
1028infixl 9 .@>
1028infixl 9 .@>
1029(.@>) = unsafeBinaryOp "@>"
1029(.@>) = unsafeBinaryOp "@>"
1031-- | Are the left JSON path/value entries contained at the top level within the
1031-- | Are the left JSON path/value entries contained at the top level within the
1032-- right JSON value?
1032-- right JSON value?
1034− :: Expression db from grouping params (nullity 'PGjsonb)
1034+ :: Expression db params grp from (nullity 'PGjsonb)
1035− -> Expression db from grouping params (nullity 'PGjsonb)
1035+ -> Expression db params grp from (nullity 'PGjsonb)
1036− -> Condition db from grouping params
1036+ -> Condition db params grp from
1037infixl 9 .<@
1037infixl 9 .<@
1038(.<@) = unsafeBinaryOp "<@"
1038(.<@) = unsafeBinaryOp "<@"
1040-- | Does the string exist as a top-level key within the JSON value?
1040-- | Does the string exist as a top-level key within the JSON value?
1042− :: Expression db from grouping params (nullity 'PGjsonb)
1042+ :: Expression db params grp from (nullity 'PGjsonb)
1043− -> Expression db from grouping params (nullity 'PGtext)
1043+ -> Expression db params grp from (nullity 'PGtext)
1044− -> Condition db from grouping params
1044+ -> Condition db params grp from
1045infixl 9 .?
1045infixl 9 .?
1046(.?) = unsafeBinaryOp "?"
1046(.?) = unsafeBinaryOp "?"
1048-- | Do any of these array strings exist as top-level keys?
1048-- | Do any of these array strings exist as top-level keys?
1050− :: Expression db from grouping params (nullity 'PGjsonb)
1050+ :: Expression db params grp from (nullity 'PGjsonb)
1051− -> Expression db from grouping params (nullity ('PGvararray ('NotNull 'PGtext)))
1051+ -> Expression db params grp from (nullity ('PGvararray ('NotNull 'PGtext)))
1052− -> Condition db from grouping params
1052+ -> Condition db params grp from
1053infixl 9 .?|
1053infixl 9 .?|
1054(.?|) = unsafeBinaryOp "?|"
1054(.?|) = unsafeBinaryOp "?|"
1056-- | Do all of these array strings exist as top-level keys?
1056-- | Do all of these array strings exist as top-level keys?
1058− :: Expression db from grouping params (nullity 'PGjsonb)
1058+ :: Expression db params grp from (nullity 'PGjsonb)
1059− -> Expression db from grouping params (nullity ('PGvararray ('NotNull 'PGtext)))
1059+ -> Expression db params grp from (nullity ('PGvararray ('NotNull 'PGtext)))
1060− -> Condition db from grouping params
1060+ -> Condition db params grp from
1061infixl 9 .?&
1061infixl 9 .?&
1062(.?&) = unsafeBinaryOp "?&"
1062(.?&) = unsafeBinaryOp "?&"
@@ -1080,9 +1080,9 @@ instance
1080-- count from the end). Throws an error if top level container is not an array.
1080-- count from the end). Throws an error if top level container is not an array.
1082 :: (key `In` '[ 'PGtext, 'PGvararray ('NotNull 'PGtext), 'PGint4, 'PGint2 ]) -- hlint error without parens here
1082 :: (key `In` '[ 'PGtext, 'PGvararray ('NotNull 'PGtext), 'PGint4, 'PGint2 ]) -- hlint error without parens here
1083− => Expression db from grouping params (nullity 'PGjsonb)
1083+ => Expression db params grp from (nullity 'PGjsonb)
1084− -> Expression db from grouping params (nullity key)
1084+ -> Expression db params grp from (nullity key)
1085− -> Expression db from grouping params (nullity 'PGjsonb)
1085+ -> Expression db params grp from (nullity 'PGjsonb)
1086infixl 6 .-.
1086infixl 6 .-.
1087(.-.) = unsafeBinaryOp "-"
1087(.-.) = unsafeBinaryOp "-"
@@ -1090,9 +1090,9 @@ infixl 6 .-.
1090-- integers count from the end)
1090-- integers count from the end)
1092 :: PGTextArray "(#-.)" arrayty
1092 :: PGTextArray "(#-.)" arrayty
1093− => Expression db from grouping params (nullity 'PGjsonb)
1093+ => Expression db params grp from (nullity 'PGjsonb)
1094− -> Expression db from grouping params (nullity arrayty)
1094+ -> Expression db params grp from (nullity arrayty)
1095− -> Expression db from grouping params (nullity 'PGjsonb)
1095+ -> Expression db params grp from (nullity 'PGjsonb)
1096infixl 6 #-.
1096infixl 6 #-.
1097(#-.) = unsafeBinaryOp "#-"
1097(#-.) = unsafeBinaryOp "#-"
@@ -1103,14 +1103,14 @@ Table 9.45: JSON creation functions
1103-- | Literal binary JSON
1103-- | Literal binary JSON
1105 :: JSON.ToJSON x
1105 :: JSON.ToJSON x
1106− => x -> Expression (commons :=> schemas) from grouping params (nullity 'PGjsonb)
1106+ => x -> Expression (commons :=> schemas) params grp from (nullity 'PGjsonb)
1107jsonbLit = cast jsonb . UnsafeExpression
1107jsonbLit = cast jsonb . UnsafeExpression
1108 . singleQuotedUtf8 . toStrict . JSON.encode
1108 . singleQuotedUtf8 . toStrict . JSON.encode
1110-- | Literal JSON
1110-- | Literal JSON
1112 :: JSON.ToJSON x
1112 :: JSON.ToJSON x
1113− => x -> Expression (commons :=> schemas) from grouping params (nullity 'PGjson)
1113+ => x -> Expression (commons :=> schemas) params grp from (nullity 'PGjson)
1114jsonLit = cast json . UnsafeExpression
1114jsonLit = cast json . UnsafeExpression
1115 . singleQuotedUtf8 . toStrict . JSON.encode
1115 . singleQuotedUtf8 . toStrict . JSON.encode
@@ -1121,8 +1121,8 @@ jsonLit = cast json . UnsafeExpression
1121-- number, a Boolean, or a null value, the text representation will be used, in
1121-- number, a Boolean, or a null value, the text representation will be used, in
1122-- such a fashion that it is a valid json value.
1122-- such a fashion that it is a valid json value.
1124− :: Expression db from grouping params (nullity ty)
1124+ :: Expression db params grp from (nullity ty)
1125− -> Expression db from grouping params (nullity 'PGjson)
1125+ -> Expression db params grp from (nullity 'PGjson)
1126toJson = unsafeFunction "to_json"
1126toJson = unsafeFunction "to_json"
1128-- | Returns the value as jsonb. Arrays and composites are converted
1128-- | Returns the value as jsonb. Arrays and composites are converted
@@ -1132,56 +1132,59 @@ toJson = unsafeFunction "to_json"
1132-- number, a Boolean, or a null value, the text representation will be used, in
1132-- number, a Boolean, or a null value, the text representation will be used, in
1133-- such a fashion that it is a valid jsonb value.
1133-- such a fashion that it is a valid jsonb value.
1135− :: Expression db from grouping params (nullity ty)
1135+ :: Expression db params grp from (nullity ty)
1136− -> Expression db from grouping params (nullity 'PGjsonb)
1136+ -> Expression db params grp from (nullity 'PGjsonb)
1137toJsonb = unsafeFunction "to_jsonb"
1137toJsonb = unsafeFunction "to_jsonb"
1139-- | Returns the array as a JSON array. A PostgreSQL multidimensional array
1139-- | Returns the array as a JSON array. A PostgreSQL multidimensional array
1140-- becomes a JSON array of arrays.
1140-- becomes a JSON array of arrays.
1141arrayToJson
1141arrayToJson
1142 :: PGArray "arrayToJson" arr
1142 :: PGArray "arrayToJson" arr
1143− => Expression db from grouping params (nullity arr)
1143+ => Expression db params grp from (nullity arr)
1144− -> Expression db from grouping params (nullity 'PGjson)
1144+ -> Expression db params grp from (nullity 'PGjson)
1145arrayToJson = unsafeFunction "array_to_json"
1145arrayToJson = unsafeFunction "array_to_json"
1147-- | Returns the row as a JSON object.
1147-- | Returns the row as a JSON object.
1148rowToJson
1148rowToJson
1149− :: Expression db from grouping params (nullity ('PGcomposite ty))
1149+ :: Expression db params grp from (nullity ('PGcomposite ty))
1150− -> Expression db from grouping params (nullity 'PGjson)
1150+ -> Expression db params grp from (nullity 'PGjson)
1151rowToJson = unsafeFunction "row_to_json"
1151rowToJson = unsafeFunction "row_to_json"
1153-- | Builds a possibly-heterogeneously-typed JSON array out of a variadic
1153-- | Builds a possibly-heterogeneously-typed JSON array out of a variadic
1154-- argument list.
1154-- argument list.
1155jsonBuildArray
1155jsonBuildArray
1156 :: SListI elems
1156 :: SListI elems
1157− => NP (Expression db from grouping params) elems
1157+ => NP (Expression db params grp from) elems
1158− -> Expression db from grouping params (nullity 'PGjson)
1158+ -> Expression db params grp from (nullity 'PGjson)
1159jsonBuildArray = unsafeVariadicFunction "json_build_array"
1159jsonBuildArray = unsafeVariadicFunction "json_build_array"
1161-- | Builds a possibly-heterogeneously-typed (binary) JSON array out of a
1161-- | Builds a possibly-heterogeneously-typed (binary) JSON array out of a
1162-- variadic argument list.
1162-- variadic argument list.
1163jsonbBuildArray
1163jsonbBuildArray
1164 :: SListI elems
1164 :: SListI elems
1165− => NP (Expression db from grouping params) elems
1165+ => NP (Expression db params grp from) elems
1166− -> Expression db from grouping params (nullity 'PGjsonb)
1166+ -> Expression db params grp from (nullity 'PGjsonb)
1167jsonbBuildArray = unsafeVariadicFunction "jsonb_build_array"
1167jsonbBuildArray = unsafeVariadicFunction "jsonb_build_array"
1169unsafeRowFunction
1169unsafeRowFunction
1170 :: All Top elems
1170 :: All Top elems
1171− => NP (Aliased (Expression db from grouping params)) elems
1171+ => NP (Aliased (Expression db params grp from)) elems
1172 -> [ByteString]
1172 -> [ByteString]
1173unsafeRowFunction =
1173unsafeRowFunction =
1174 (`appEndo` []) . hcfoldMap (Proxy :: Proxy Top)
1174 (`appEndo` []) . hcfoldMap (Proxy :: Proxy Top)
1175 (\(col `As` name) -> Endo $ \xs ->
1175 (\(col `As` name) -> Endo $ \xs ->
1176− renderAliasString name : renderExpression col : xs)
1176+ renderAliasString name : renderSQL col : xs)
1178+ renderAliasString :: KnownSymbol alias => Alias alias -> ByteString
1179+ renderAliasString = singleQuotedText . fromString . symbolVal
1178-- | Builds a possibly-heterogeneously-typed JSON object out of a variadic
1181-- | Builds a possibly-heterogeneously-typed JSON object out of a variadic
1179-- argument list. The elements of the argument list must alternate between text
1182-- argument list. The elements of the argument list must alternate between text
1180-- and values.
1183-- and values.
1181jsonBuildObject
1184jsonBuildObject
1182 :: All Top elems
1185 :: All Top elems
1183− => NP (Aliased (Expression db from grouping params)) elems
1186+ => NP (Aliased (Expression db params grp from)) elems
1184− -> Expression db from grouping params (nullity 'PGjson)
1187+ -> Expression db params grp from (nullity 'PGjson)
1185jsonBuildObject
1188jsonBuildObject
1186 = unsafeFunction "json_build_object"
1189 = unsafeFunction "json_build_object"
1187 . UnsafeExpression
1190 . UnsafeExpression
@@ -1193,8 +1196,8 @@ jsonBuildObject
1193-- between text and values.
1196-- between text and values.
1194jsonbBuildObject
1197jsonbBuildObject
1195 :: All Top elems
1198 :: All Top elems
1196− => NP (Aliased (Expression db from grouping params)) elems
1199+ => NP (Aliased (Expression db params grp from)) elems
1197− -> Expression db from grouping params (nullity 'PGjsonb)
1200+ -> Expression db params grp from (nullity 'PGjsonb)
1198jsonbBuildObject
1201jsonbBuildObject
1199 = unsafeFunction "jsonb_build_object"
1202 = unsafeFunction "jsonb_build_object"
1200 . UnsafeExpression
1203 . UnsafeExpression
@@ -1207,8 +1210,8 @@ jsonbBuildObject
1207-- array has exactly two elements, which are taken as a key/value pair.
1210-- array has exactly two elements, which are taken as a key/value pair.
1208jsonObject
1211jsonObject
1209 :: PGArrayOf "jsonObject" arr ('NotNull 'PGtext)
1212 :: PGArrayOf "jsonObject" arr ('NotNull 'PGtext)
1210− => Expression db from grouping params (nullity arr)
1213+ => Expression db params grp from (nullity arr)
1211− -> Expression db from grouping params (nullity 'PGjson)
1214+ -> Expression db params grp from (nullity 'PGjson)
1212jsonObject = unsafeFunction "json_object"
1215jsonObject = unsafeFunction "json_object"
1214-- | Builds a binary JSON object out of a text array. The array must have either
1217-- | Builds a binary JSON object out of a text array. The array must have either
@@ -1217,8 +1220,8 @@ jsonObject = unsafeFunction "json_object"
1217-- array has exactly two elements, which are taken as a key/value pair.
1220-- array has exactly two elements, which are taken as a key/value pair.
1218jsonbObject
1221jsonbObject
1219 :: PGArrayOf "jsonbObject" arr ('NotNull 'PGtext)
1222 :: PGArrayOf "jsonbObject" arr ('NotNull 'PGtext)
1220− => Expression db from grouping params (nullity arr)
1223+ => Expression db params grp from (nullity arr)
1221− -> Expression db from grouping params (nullity 'PGjsonb)
1224+ -> Expression db params grp from (nullity 'PGjsonb)
1222jsonbObject = unsafeFunction "jsonb_object"
1225jsonbObject = unsafeFunction "jsonb_object"
1224-- | This is an alternate form of 'jsonObject' that takes two arrays; one for
1227-- | This is an alternate form of 'jsonObject' that takes two arrays; one for
@@ -1226,9 +1229,9 @@ jsonbObject = unsafeFunction "jsonb_object"
1226jsonZipObject
1229jsonZipObject
1227 :: ( PGArrayOf "jsonZipObject" keysArray ('NotNull 'PGtext)
1230 :: ( PGArrayOf "jsonZipObject" keysArray ('NotNull 'PGtext)
1228 , PGArrayOf "jsonZipObject" valuesArray ('NotNull 'PGtext))
1231 , PGArrayOf "jsonZipObject" valuesArray ('NotNull 'PGtext))
1229− => Expression db from grouping params (nullity keysArray)
1232+ => Expression db params grp from (nullity keysArray)
1230− -> Expression db from grouping params (nullity valuesArray)
1233+ -> Expression db params grp from (nullity valuesArray)
1231− -> Expression db from grouping params (nullity 'PGjson)
1234+ -> Expression db params grp from (nullity 'PGjson)
1232jsonZipObject ks vs =
1235jsonZipObject ks vs =
1233 unsafeVariadicFunction "json_object" (ks :* vs :* Nil)
1236 unsafeVariadicFunction "json_object" (ks :* vs :* Nil)
@@ -1238,9 +1241,9 @@ jsonZipObject ks vs =
1238jsonbZipObject
1241jsonbZipObject
1239 :: ( PGArrayOf "jsonbZipObject" keysArray ('NotNull 'PGtext)
1242 :: ( PGArrayOf "jsonbZipObject" keysArray ('NotNull 'PGtext)
1240 , PGArrayOf "jsonbZipObject" valuesArray ('NotNull 'PGtext))
1243 , PGArrayOf "jsonbZipObject" valuesArray ('NotNull 'PGtext))
1241− => Expression db from grouping params (nullity keysArray)
1244+ => Expression db params grp from (nullity keysArray)
1242− -> Expression db from grouping params (nullity valuesArray)
1245+ -> Expression db params grp from (nullity valuesArray)
1243− -> Expression db from grouping params (nullity 'PGjsonb)
1246+ -> Expression db params grp from (nullity 'PGjsonb)
1244jsonbZipObject ks vs =
1247jsonbZipObject ks vs =
1245 unsafeVariadicFunction "jsonb_object" (ks :* vs :* Nil)
1248 unsafeVariadicFunction "jsonb_object" (ks :* vs :* Nil)
@@ -1250,23 +1253,23 @@ Table 9.46: JSON processing functions
1251-- | Returns the number of elements in the outermost JSON array.
1254-- | Returns the number of elements in the outermost JSON array.
1252jsonArrayLength
1255jsonArrayLength
1253− :: Expression db from grouping params (nullity 'PGjson)
1256+ :: Expression db params grp from (nullity 'PGjson)
1254− -> Expression db from grouping params (nullity 'PGint4)
1257+ -> Expression db params grp from (nullity 'PGint4)
1255jsonArrayLength = unsafeFunction "json_array_length"
1258jsonArrayLength = unsafeFunction "json_array_length"
1257-- | Returns the number of elements in the outermost binary JSON array.
1260-- | Returns the number of elements in the outermost binary JSON array.
1258jsonbArrayLength
1261jsonbArrayLength
1259− :: Expression db from grouping params (nullity 'PGjsonb)
1262+ :: Expression db params grp from (nullity 'PGjsonb)
1260− -> Expression db from grouping params (nullity 'PGint4)
1263+ -> Expression db params grp from (nullity 'PGint4)
1261jsonbArrayLength = unsafeFunction "jsonb_array_length"
1264jsonbArrayLength = unsafeFunction "jsonb_array_length"
1263-- | Returns JSON value pointed to by the given path (equivalent to #>
1266-- | Returns JSON value pointed to by the given path (equivalent to #>
1264-- operator).
1267-- operator).
1265jsonExtractPath
1268jsonExtractPath
1266 :: SListI elems
1269 :: SListI elems
1267− => Expression db from grouping params (nullity 'PGjson)
1270+ => Expression db params grp from (nullity 'PGjson)
1268− -> NP (Expression db from grouping params) elems
1271+ -> NP (Expression db params grp from) elems
1269− -> Expression db from grouping params (nullity 'PGjsonb)
1272+ -> Expression db params grp from (nullity 'PGjsonb)
1270jsonExtractPath x xs =
1273jsonExtractPath x xs =
1271 unsafeVariadicFunction "json_extract_path" (x :* xs)
1274 unsafeVariadicFunction "json_extract_path" (x :* xs)
@@ -1274,9 +1277,9 @@ jsonExtractPath x xs =
1274-- operator).
1277-- operator).
1275jsonbExtractPath
1278jsonbExtractPath
1276 :: SListI elems
1279 :: SListI elems
1277− => Expression db from grouping params (nullity 'PGjsonb)
1280+ => Expression db params grp from (nullity 'PGjsonb)
1278− -> NP (Expression db from grouping params) elems
1281+ -> NP (Expression db params grp from) elems
1279− -> Expression db from grouping params (nullity 'PGjsonb)
1282+ -> Expression db params grp from (nullity 'PGjsonb)
1280jsonbExtractPath x xs =
1283jsonbExtractPath x xs =
1281 unsafeVariadicFunction "jsonb_extract_path" (x :* xs)
1284 unsafeVariadicFunction "jsonb_extract_path" (x :* xs)
@@ -1284,9 +1287,9 @@ jsonbExtractPath x xs =
1284-- operator), as text.
1287-- operator), as text.
1285jsonExtractPathAsText
1288jsonExtractPathAsText
1286 :: SListI elems
1289 :: SListI elems
1287− => Expression db from grouping params (nullity 'PGjson)
1290+ => Expression db params grp from (nullity 'PGjson)
1288− -> NP (Expression db from grouping params) elems
1291+ -> NP (Expression db params grp from) elems
1289− -> Expression db from grouping params (nullity 'PGjson)
1292+ -> Expression db params grp from (nullity 'PGjson)
1290jsonExtractPathAsText x xs =
1293jsonExtractPathAsText x xs =
1291 unsafeVariadicFunction "json_extract_path_text" (x :* xs)
1294 unsafeVariadicFunction "json_extract_path_text" (x :* xs)
@@ -1294,38 +1297,38 @@ jsonExtractPathAsText x xs =
1294-- operator), as text.
1297-- operator), as text.
1295jsonbExtractPathAsText
1298jsonbExtractPathAsText
1296 :: SListI elems
1299 :: SListI elems
1297− => Expression db from grouping params (nullity 'PGjsonb)
1300+ => Expression db params grp from (nullity 'PGjsonb)
1298− -> NP (Expression db from grouping params) elems
1301+ -> NP (Expression db params grp from) elems
1299− -> Expression db from grouping params (nullity 'PGjsonb)
1302+ -> Expression db params grp from (nullity 'PGjsonb)
1300jsonbExtractPathAsText x xs =
1303jsonbExtractPathAsText x xs =
1301 unsafeVariadicFunction "jsonb_extract_path_text" (x :* xs)
1304 unsafeVariadicFunction "jsonb_extract_path_text" (x :* xs)
1303-- | Returns the type of the outermost JSON value as a text string. Possible
1306-- | Returns the type of the outermost JSON value as a text string. Possible
1304-- types are object, array, string, number, boolean, and null.
1307-- types are object, array, string, number, boolean, and null.
1305jsonTypeof
1308jsonTypeof
1306− :: Expression db from grouping params (nullity 'PGjson)
1309+ :: Expression db params grp from (nullity 'PGjson)
1307− -> Expression db from grouping params (nullity 'PGtext)
1310+ -> Expression db params grp from (nullity 'PGtext)
1308jsonTypeof = unsafeFunction "json_typeof"
1311jsonTypeof = unsafeFunction "json_typeof"
1310-- | Returns the type of the outermost binary JSON value as a text string.
1313-- | Returns the type of the outermost binary JSON value as a text string.
1311-- Possible types are object, array, string, number, boolean, and null.
1314-- Possible types are object, array, string, number, boolean, and null.
1312jsonbTypeof
1315jsonbTypeof
1313− :: Expression db from grouping params (nullity 'PGjsonb)
1316+ :: Expression db params grp from (nullity 'PGjsonb)
1314− -> Expression db from grouping params (nullity 'PGtext)
1317+ -> Expression db params grp from (nullity 'PGtext)
1315jsonbTypeof = unsafeFunction "jsonb_typeof"
1318jsonbTypeof = unsafeFunction "jsonb_typeof"
1317-- | Returns its argument with all object fields that have null values omitted.
1320-- | Returns its argument with all object fields that have null values omitted.
1318-- Other null values are untouched.
1321-- Other null values are untouched.
1319jsonStripNulls
1322jsonStripNulls
1320− :: Expression db from grouping params (nullity 'PGjson)
1323+ :: Expression db params grp from (nullity 'PGjson)
1321− -> Expression db from grouping params (nullity 'PGjson)
1324+ -> Expression db params grp from (nullity 'PGjson)
1322jsonStripNulls = unsafeFunction "json_strip_nulls"
1325jsonStripNulls = unsafeFunction "json_strip_nulls"
1324-- | Returns its argument with all object fields that have null values omitted.
1327-- | Returns its argument with all object fields that have null values omitted.
1325-- Other null values are untouched.
1328-- Other null values are untouched.
1326jsonbStripNulls
1329jsonbStripNulls
1327− :: Expression db from grouping params (nullity 'PGjsonb)
1330+ :: Expression db params grp from (nullity 'PGjsonb)
1328− -> Expression db from grouping params (nullity 'PGjsonb)
1331+ -> Expression db params grp from (nullity 'PGjsonb)
1329jsonbStripNulls = unsafeFunction "jsonb_strip_nulls"
1332jsonbStripNulls = unsafeFunction "jsonb_strip_nulls"
1331-- | @ jsonbSet target path new_value create_missing @
1334-- | @ jsonbSet target path new_value create_missing @
@@ -1337,11 +1340,11 @@ jsonbStripNulls = unsafeFunction "jsonb_strip_nulls"
1337-- arrays.
1340-- arrays.
1339 :: PGTextArray "jsonbSet" arr
1342 :: PGTextArray "jsonbSet" arr
1340− => Expression db from grouping params (nullity 'PGjsonb)
1343+ => Expression db params grp from (nullity 'PGjsonb)
1341− -> Expression db from grouping params (nullity arr)
1344+ -> Expression db params grp from (nullity arr)
1342− -> Expression db from grouping params (nullity 'PGjsonb)
1345+ -> Expression db params grp from (nullity 'PGjsonb)
1343− -> Maybe (Expression db from grouping params (nullity 'PGbool))
1346+ -> Maybe (Expression db params grp from (nullity 'PGbool))
1344− -> Expression db from grouping params (nullity 'PGjsonb)
1347+ -> Expression db params grp from (nullity 'PGjsonb)
1345jsonbSet tgt path val createMissing = case createMissing of
1348jsonbSet tgt path val createMissing = case createMissing of
1346 Just m -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* m :* Nil)
1349 Just m -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* m :* Nil)
1347 Nothing -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* Nil)
1350 Nothing -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* Nil)
@@ -1356,19 +1359,19 @@ jsonbSet tgt path val createMissing = case createMissing of
1356-- in path count from the end of JSON arrays.
1359-- in path count from the end of JSON arrays.
1357jsonbInsert
1360jsonbInsert
1358 :: PGTextArray "jsonbInsert" arr
1361 :: PGTextArray "jsonbInsert" arr
1359− => Expression db from grouping params (nullity 'PGjsonb)
1362+ => Expression db params grp from (nullity 'PGjsonb)
1360− -> Expression db from grouping params (nullity arr)
1363+ -> Expression db params grp from (nullity arr)
1361− -> Expression db from grouping params (nullity 'PGjsonb)
1364+ -> Expression db params grp from (nullity 'PGjsonb)
1362− -> Maybe (Expression db from grouping params (nullity 'PGbool))
1365+ -> Maybe (Expression db params grp from (nullity 'PGbool))
1363− -> Expression db from grouping params (nullity 'PGjsonb)
1366+ -> Expression db params grp from (nullity 'PGjsonb)
1364jsonbInsert tgt path val insertAfter = case insertAfter of
1367jsonbInsert tgt path val insertAfter = case insertAfter of
1365 Just i -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* i :* Nil)
1368 Just i -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* i :* Nil)
1366 Nothing -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* Nil)
1369 Nothing -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* Nil)
1368-- | Returns its argument as indented JSON text.
1371-- | Returns its argument as indented JSON text.
1369jsonbPretty
1372jsonbPretty
1370− :: Expression db from grouping params (nullity 'PGjsonb)
1373+ :: Expression db params grp from (nullity 'PGjsonb)
1371− -> Expression db from grouping params (nullity 'PGtext)
1374+ -> Expression db params grp from (nullity 'PGtext)
1372jsonbPretty = unsafeFunction "jsonb_pretty"
1375jsonbPretty = unsafeFunction "jsonb_pretty"
1374{-----------------------------------------
1377{-----------------------------------------
@@ -1381,7 +1384,7 @@ unsafeAggregate
1381 -> Expression db from 'Ungrouped params (xty)
1384 -> Expression db from 'Ungrouped params (xty)
1382 -> Expression db from ('Grouped bys) params (yty)
1385 -> Expression db from ('Grouped bys) params (yty)
1383unsafeAggregate fun x = UnsafeExpression $ mconcat
1386unsafeAggregate fun x = UnsafeExpression $ mconcat
1384− [fun, "(", renderExpression x, ")"]
1387+ [fun, "(", renderSQL x, ")"]
1386-- | escape hatch to define aggregate functions over distinct values
1389-- | escape hatch to define aggregate functions over distinct values
1387unsafeAggregateDistinct
1390unsafeAggregateDistinct
@@ -1389,11 +1392,11 @@ unsafeAggregateDistinct
1389 -> Expression db from 'Ungrouped params (xty)
1392 -> Expression db from 'Ungrouped params (xty)
1390 -> Expression db from ('Grouped bys) params (yty)
1393 -> Expression db from ('Grouped bys) params (yty)
1391unsafeAggregateDistinct fun x = UnsafeExpression $ mconcat
1394unsafeAggregateDistinct fun x = UnsafeExpression $ mconcat
1392− [fun, "(DISTINCT ", renderExpression x, ")"]
1395+ [fun, "(DISTINCT ", renderSQL x, ")"]
1394-- | >>> :{
1397-- | >>> :{
1396−-- expression :: Expression db '[tab ::: '["col" ::: 'Null 'PGnumeric]] ('Grouped bys) params ('Null 'PGnumeric)
1399+-- expression :: Expression db params ('Grouped bys) '[tab ::: '["col" ::: 'Null 'PGnumeric]] ('Null 'PGnumeric)
1397-- expression = sum_ #col
1400-- expression = sum_ #col
1398-- in printSQL expression
1401-- in printSQL expression
@@ -1407,7 +1410,7 @@ sum_ = unsafeAggregate "sum"
1408-- | >>> :{
1411-- | >>> :{
1410−-- expression :: Expression db '[tab ::: '["col" ::: nullity 'PGnumeric]] ('Grouped bys) params (nullity 'PGnumeric)
1413+-- expression :: Expression db params ('Grouped bys) '[tab ::: '["col" ::: nullity 'PGnumeric]] (nullity 'PGnumeric)
1411-- expression = sumDistinct #col
1414-- expression = sumDistinct #col
1412-- in printSQL expression
1415-- in printSQL expression
@@ -1438,7 +1441,7 @@ instance PGAvg 'PGinterval 'PGinterval
1439-- | >>> :{
1442-- | >>> :{
1441−-- expression :: Expression db '[tab ::: '["col" ::: nullity 'PGint4]] (Grouped bys) params (nullity 'PGint4)
1444+-- expression :: Expression db params (Grouped bys) '[tab ::: '["col" ::: nullity 'PGint4]] (nullity 'PGint4)
1442-- expression = bitAnd #col
1445-- expression = bitAnd #col
1443-- in printSQL expression
1446-- in printSQL expression
@@ -1452,7 +1455,7 @@ bitAnd = unsafeAggregate "bit_and"
1453-- | >>> :{
1456-- | >>> :{
1455−-- expression :: Expression db '[tab ::: '["col" ::: nullity 'PGint4]] (Grouped bys) params (nullity 'PGint4)
1458+-- expression :: Expression db params ('Grouped bys) '[tab ::: '["col" ::: nullity 'PGint4]] (nullity 'PGint4)
1456-- expression = bitOr #col
1459-- expression = bitOr #col
1457-- in printSQL expression
1460-- in printSQL expression
@@ -1466,7 +1469,7 @@ bitOr = unsafeAggregate "bit_or"
1467-- | >>> :{
1470-- | >>> :{
1469−-- expression :: Expression db '[tab ::: '["col" ::: nullity 'PGint4]] (Grouped bys) params (nullity 'PGint4)
1472+-- expression :: Expression db params ('Grouped bys) '[tab ::: '["col" ::: nullity 'PGint4]] (nullity 'PGint4)
1470-- expression = bitAndDistinct #col
1473-- expression = bitAndDistinct #col
1471-- in printSQL expression
1474-- in printSQL expression
@@ -1480,7 +1483,7 @@ bitAndDistinct = unsafeAggregateDistinct "bit_and"
1481-- | >>> :{
1484-- | >>> :{
1483−-- expression :: Expression db '[tab ::: '["col" ::: nullity 'PGint4]] (Grouped bys) params (nullity 'PGint4)
1486+-- expression :: Expression db params (Grouped bys) '[tab ::: '["col" ::: nullity 'PGint4]] (nullity 'PGint4)
1484-- expression = bitOrDistinct #col
1487-- expression = bitOrDistinct #col
1485-- in printSQL expression
1488-- in printSQL expression
@@ -1494,7 +1497,7 @@ bitOrDistinct = unsafeAggregateDistinct "bit_or"
1495-- | >>> :{
1498-- | >>> :{
1497−-- expression :: Expression db '[tab ::: '["col" ::: nullity 'PGbool]] (Grouped bys) params (nullity 'PGbool)
1500+-- expression :: Expression db params (Grouped bys) '[tab ::: '["col" ::: nullity 'PGbool]] (nullity 'PGbool)
1498-- expression = boolAnd #col
1501-- expression = boolAnd #col
1499-- in printSQL expression
1502-- in printSQL expression
@@ -1507,7 +1510,7 @@ boolAnd = unsafeAggregate "bool_and"
1508-- | >>> :{
1511-- | >>> :{
1510−-- expression :: Expression db '[tab ::: '["col" ::: nullity 'PGbool]] (Grouped bys) params (nullity 'PGbool)
1513+-- expression :: Expression db params (Grouped bys) '[tab ::: '["col" ::: nullity 'PGbool]] (nullity 'PGbool)
1511-- expression = boolOr #col
1514-- expression = boolOr #col
1512-- in printSQL expression
1515-- in printSQL expression
@@ -1520,7 +1523,7 @@ boolOr = unsafeAggregate "bool_or"
1521-- | >>> :{
1524-- | >>> :{
1523−-- expression :: Expression db '[tab ::: '["col" ::: nullity 'PGbool]] (Grouped bys) params (nullity 'PGbool)
1526+-- expression :: Expression db params (Grouped bys) '[tab ::: '["col" ::: nullity 'PGbool]] (nullity 'PGbool)
1524-- expression = boolAndDistinct #col
1527-- expression = boolAndDistinct #col
1525-- in printSQL expression
1528-- in printSQL expression
@@ -1533,7 +1536,7 @@ boolAndDistinct = unsafeAggregateDistinct "bool_and"
1534-- | >>> :{
1537-- | >>> :{
1536−-- expression :: Expression db '[tab ::: '["col" ::: nullity 'PGbool]] (Grouped bys) params (nullity 'PGbool)
1539+-- expression :: Expression db params (Grouped bys) '[tab ::: '["col" ::: nullity 'PGbool]] (nullity 'PGbool)
1537-- expression = boolOrDistinct #col
1540-- expression = boolOrDistinct #col
1538-- in printSQL expression
1541-- in printSQL expression
@@ -1554,7 +1557,7 @@ countStar = UnsafeExpression $ "count(*)"
1555-- | >>> :{
1558-- | >>> :{
1557−-- expression :: Expression db '[tab ::: '["col" ::: nullity ty]] (Grouped bys) params ('NotNull 'PGint8)
1560+-- expression :: Expression db params (Grouped bys) '[tab ::: '["col" ::: nullity ty]] ('NotNull 'PGint8)
1558-- expression = count #col
1561-- expression = count #col
1559-- in printSQL expression
1562-- in printSQL expression
@@ -1567,7 +1570,7 @@ count = unsafeAggregate "count"
1568-- | >>> :{
1571-- | >>> :{
1570−-- expression :: Expression db '[tab ::: '["col" ::: nullity ty]] (Grouped bys) params ('NotNull 'PGint8)
1573+-- expression :: Expression db params (Grouped bys) '[tab ::: '["col" ::: nullity ty]] ('NotNull 'PGint8)
1571-- expression = countDistinct #col
1574-- expression = countDistinct #col
1572-- in printSQL expression
1575-- in printSQL expression
@@ -1582,7 +1585,7 @@ countDistinct = unsafeAggregateDistinct "count"
1583-- >>> :{
1586-- >>> :{
1585−-- expression :: Expression db '[tab ::: '["col" ::: nullity 'PGbool]] (Grouped bys) params (nullity 'PGbool)
1588+-- expression :: Expression db params (Grouped bys) '[tab ::: '["col" ::: nullity 'PGbool]] (nullity 'PGbool)
1586-- expression = every #col
1589-- expression = every #col
1587-- in printSQL expression
1590-- in printSQL expression
@@ -1597,7 +1600,7 @@ every = unsafeAggregate "every"
1598-- >>> :{
1601-- >>> :{
1600−-- expression :: Expression db '[tab ::: '["col" ::: nullity 'PGbool]] (Grouped bys) params (nullity 'PGbool)
1603+-- expression :: Expression db params (Grouped bys) '[tab ::: '["col" ::: nullity 'PGbool]] (nullity 'PGbool)
1601-- expression = everyDistinct #col
1604-- expression = everyDistinct #col
1602-- in printSQL expression
1605-- in printSQL expression
@@ -1626,13 +1629,15 @@ type expressions
1626newtype TypeExpression (schemas :: SchemasType) (ty :: NullityType)
1629newtype TypeExpression (schemas :: SchemasType) (ty :: NullityType)
1627 = UnsafeTypeExpression { renderTypeExpression :: ByteString }
1630 = UnsafeTypeExpression { renderTypeExpression :: ByteString }
1628 deriving (GHC.Generic,Show,Eq,Ord,NFData)
1631 deriving (GHC.Generic,Show,Eq,Ord,NFData)
1632+instance RenderSQL (TypeExpression schemas ty) where
1633+ renderSQL = renderTypeExpression
1630-- | The enum or composite type in a `Typedef` can be expressed by its alias.
1635-- | The enum or composite type in a `Typedef` can be expressed by its alias.
1632 :: (Has sch schemas schema, Has td schema ('Typedef ty))
1637 :: (Has sch schemas schema, Has td schema ('Typedef ty))
1633 => QualifiedAlias sch td
1638 => QualifiedAlias sch td
1634 -> TypeExpression schemas (nullity ty)
1639 -> TypeExpression schemas (nullity ty)
1635−typedef = UnsafeTypeExpression . renderQualifiedAlias
1640+typedef = UnsafeTypeExpression . renderSQL
1637-- | The composite type corresponding to a `Table` definition can be expressed
1642-- | The composite type corresponding to a `Table` definition can be expressed
1638-- by its alias.
1643-- by its alias.
@@ -1640,7 +1645,7 @@ typetable
1640 :: (Has sch schemas schema, Has tab schema ('Table table))
1645 :: (Has sch schemas schema, Has tab schema ('Table table))
1641 => QualifiedAlias sch tab
1646 => QualifiedAlias sch tab
1642 -> TypeExpression schemas (nullity ('PGcomposite (TableToRow table)))
1647 -> TypeExpression schemas (nullity ('PGcomposite (TableToRow table)))
1643−typetable = UnsafeTypeExpression . renderQualifiedAlias
1648+typetable = UnsafeTypeExpression . renderSQL
1645-- | The composite type corresponding to a `View` definition can be expressed
1650-- | The composite type corresponding to a `View` definition can be expressed
1646-- by its alias.
1651-- by its alias.
@@ -1648,7 +1653,7 @@ typeview
1648 :: (Has sch schemas schema, Has vw schema ('View view))
1653 :: (Has sch schemas schema, Has vw schema ('View view))
1649 => QualifiedAlias sch vw
1654 => QualifiedAlias sch vw
1650 -> TypeExpression schemas (nullity ('PGcomposite view))
1655 -> TypeExpression schemas (nullity ('PGcomposite view))
1651−typeview = UnsafeTypeExpression . renderQualifiedAlias
1656+typeview = UnsafeTypeExpression . renderSQL
1653-- | logical Boolean (true/false)
1658-- | logical Boolean (true/false)
1654bool :: TypeExpression schemas (nullity 'PGbool)
1659bool :: TypeExpression schemas (nullity 'PGbool)
@@ -1730,17 +1735,17 @@ jsonb = UnsafeTypeExpression "jsonb"
1731 :: TypeExpression schemas pg
1736 :: TypeExpression schemas pg
1732 -> TypeExpression schemas (nullity ('PGvararray pg))
1737 -> TypeExpression schemas (nullity ('PGvararray pg))
1733−vararray ty = UnsafeTypeExpression $ renderTypeExpression ty <> "[]"
1738+vararray ty = UnsafeTypeExpression $ renderSQL ty <> "[]"
1734-- | fixed length array
1739-- | fixed length array
1736−-- >>> renderTypeExpression (fixarray @2 json)
1741+-- >>> renderSQL (fixarray @2 json)
1737-- "json[2]"
1742-- "json[2]"
1739 :: forall n schemas nullity pg. KnownNat n
1744 :: forall n schemas nullity pg. KnownNat n
1740 => TypeExpression schemas pg
1745 => TypeExpression schemas pg
1741 -> TypeExpression schemas (nullity ('PGfixarray n pg))
1746 -> TypeExpression schemas (nullity ('PGfixarray n pg))
1742fixarray ty = UnsafeTypeExpression $
1747fixarray ty = UnsafeTypeExpression $
1743− renderTypeExpression ty <> "[" <> renderNat @n <> "]"
1748+ renderSQL ty <> "[" <> renderNat @n <> "]"
1745-- | `pgtype` is a demoted version of a `PGType`
1750-- | `pgtype` is a demoted version of a `PGType`
1746class PGTyped schemas (ty :: NullityType) where
1751class PGTyped schemas (ty :: NullityType) where