@@ -237,6 +237,7 @@ values from primitive expression using arithmetic, logical,
237and other operations.
237and other operations.
239newtype Expression
239newtype Expression
240 (grp :: Grouping)
241 (grp :: Grouping)
241 (commons :: FromType)
242 (commons :: FromType)
242 (schemas :: SchemasType)
243 (schemas :: SchemasType)
@@ -246,7 +247,7 @@ newtype Expression
246 = UnsafeExpression { renderExpression :: ByteString }
247 = UnsafeExpression { renderExpression :: ByteString }
247 deriving (GHC.Generic,Show,Eq,Ord,NFData)
248 deriving (GHC.Generic,Show,Eq,Ord,NFData)
249−instance RenderSQL (Expression grp commons schemas params from ty) where
250+instance RenderSQL (Expression outer grp commons schemas params from ty) where
250 renderSQL = renderExpression
251 renderSQL = renderExpression
252{- | A `HasParameter` constraint is used to indicate a value that is
253{- | A `HasParameter` constraint is used to indicate a value that is
@@ -264,12 +265,12 @@ class KnownNat n => HasParameter
264 | n params -> ty where
265 | n params -> ty where
265 -- | `parameter` takes a `Nat` using type application and a `TypeExpression`.
266 -- | `parameter` takes a `Nat` using type application and a `TypeExpression`.
267− -- >>> let expr = parameter @1 int4 :: Expression grp '[] schemas '[ 'Null 'PGint4] from ('Null 'PGint4)
268+ -- >>> let expr = parameter @1 int4 :: Expression outer grp '[] schemas '[ 'Null 'PGint4] from ('Null 'PGint4)
268 -- >>> printSQL expr
269 -- >>> printSQL expr
269 -- ($1 :: int4)
270 -- ($1 :: int4)
270 parameter
271 parameter
271 :: TypeExpression schemas ty
272 :: TypeExpression schemas ty
272− -> Expression grp commons schemas params from ty
273+ -> Expression outer grp commons schemas params from ty
273 parameter ty = UnsafeExpression $ parenthesized $
274 parameter ty = UnsafeExpression $ parenthesized $
274 "$" <> renderNat @n <+> "::"
275 "$" <> renderNat @n <+> "::"
275 <+> renderSQL ty
276 <+> renderSQL ty
@@ -280,116 +281,116 @@ instance {-# OVERLAPPABLE #-} (KnownNat n, HasParameter (n-1) params ty)
280-- | `param` takes a `Nat` using type application and for basic types,
281-- | `param` takes a `Nat` using type application and for basic types,
281-- infers a `TypeExpression`.
282-- infers a `TypeExpression`.
283−-- >>> let expr = param @1 :: Expression grp commons schemas '[ 'Null 'PGint4] from ('Null 'PGint4)
284+-- >>> let expr = param @1 :: Expression outer grp commons schemas '[ 'Null 'PGint4] from ('Null 'PGint4)
284-- >>> printSQL expr
285-- >>> printSQL expr
285-- ($1 :: int4)
286-- ($1 :: int4)
287− :: forall n commons schemas params from grp ty
288+ :: forall n outer commons schemas params from grp ty
288 . (PGTyped schemas ty, HasParameter n params ty)
289 . (PGTyped schemas ty, HasParameter n params ty)
289− => Expression grp commons schemas params from ty -- ^ param
290+ => Expression outer grp commons schemas params from ty -- ^ param
290param = parameter @n (pgtype @schemas)
291param = parameter @n (pgtype @schemas)
292−instance (HasUnique tab from row, Has col row ty)
293+instance (HasUnique tab (Join outer from) row, Has col row ty)
293− => IsLabel col (Expression 'Ungrouped commons schemas params from ty) where
294+ => IsLabel col (Expression outer 'Ungrouped commons schemas params from ty) where
294 fromLabel = UnsafeExpression $ renderSQL (Alias @col)
295 fromLabel = UnsafeExpression $ renderSQL (Alias @col)
295−instance (HasUnique tab from row, Has col row ty, tys ~ '[ty])
296+instance (HasUnique tab (Join outer from) row, Has col row ty, tys ~ '[ty])
296− => IsLabel col (NP (Expression 'Ungrouped commons schemas params from) tys) where
297+ => IsLabel col (NP (Expression outer 'Ungrouped commons schemas params from) tys) where
297 fromLabel = fromLabel @col :* Nil
298 fromLabel = fromLabel @col :* Nil
298−instance (HasUnique tab from row, Has col row ty, column ~ (col ::: ty))
299+instance (HasUnique tab (Join outer from) row, Has col row ty, column ~ (col ::: ty))
299 => IsLabel col
300 => IsLabel col
300− (Aliased (Expression 'Ungrouped commons schemas params from) column) where
301+ (Aliased (Expression outer 'Ungrouped commons schemas params from) column) where
301 fromLabel = fromLabel @col `As` Alias
302 fromLabel = fromLabel @col `As` Alias
302−instance (HasUnique tab from row, Has col row ty, columns ~ '[col ::: ty])
303+instance (HasUnique tab (Join outer from) row, Has col row ty, columns ~ '[col ::: ty])
303 => IsLabel col
304 => IsLabel col
304− (NP (Aliased (Expression 'Ungrouped commons schemas params from)) columns) where
305+ (NP (Aliased (Expression outer 'Ungrouped commons schemas params from)) columns) where
305 fromLabel = fromLabel @col :* Nil
306 fromLabel = fromLabel @col :* Nil
307−instance (Has tab from row, Has col row ty)
308+instance (Has tab (Join outer from) row, Has col row ty)
308− => IsQualified tab col (Expression 'Ungrouped commons schemas params from ty) where
309+ => IsQualified tab col (Expression outer 'Ungrouped commons schemas params from ty) where
309 tab ! col = UnsafeExpression $
310 tab ! col = UnsafeExpression $
310 renderSQL tab <> "." <> renderSQL col
311 renderSQL tab <> "." <> renderSQL col
311−instance (Has tab from row, Has col row ty, tys ~ '[ty])
312+instance (Has tab (Join outer from) row, Has col row ty, tys ~ '[ty])
312− => IsQualified tab col (NP (Expression 'Ungrouped commons schemas params from) tys) where
313+ => IsQualified tab col (NP (Expression outer 'Ungrouped commons schemas params from) tys) where
313 tab ! col = tab ! col :* Nil
314 tab ! col = tab ! col :* Nil
314−instance (Has tab from row, Has col row ty, column ~ (col ::: ty))
315+instance (Has tab (Join outer from) row, Has col row ty, column ~ (col ::: ty))
315 => IsQualified tab col
316 => IsQualified tab col
316− (Aliased (Expression 'Ungrouped commons schemas params from) column) where
317+ (Aliased (Expression outer 'Ungrouped commons schemas params from) column) where
317 tab ! col = tab ! col `As` col
318 tab ! col = tab ! col `As` col
318−instance (Has tab from row, Has col row ty, columns ~ '[col ::: ty])
319+instance (Has tab (Join outer from) row, Has col row ty, columns ~ '[col ::: ty])
319 => IsQualified tab col
320 => IsQualified tab col
320− (NP (Aliased (Expression 'Ungrouped commons schemas params from)) columns) where
321+ (NP (Aliased (Expression outer 'Ungrouped commons schemas params from)) columns) where
321 tab ! col = tab ! col :* Nil
322 tab ! col = tab ! col :* Nil
324− ( HasUnique tab from row
325+ ( HasUnique tab (Join outer from) row
325 , Has col row ty
326 , Has col row ty
326 , GroupedBy tab col bys
327 , GroupedBy tab col bys
327 ) => IsLabel col
328 ) => IsLabel col
328− (Expression ('Grouped bys) commons schemas params from ty) where
329+ (Expression outer ('Grouped bys) commons schemas params from ty) where
329 fromLabel = UnsafeExpression $ renderSQL (Alias @col)
330 fromLabel = UnsafeExpression $ renderSQL (Alias @col)
331− ( HasUnique tab from row
332+ ( HasUnique tab (Join outer from) row
332 , Has col row ty
333 , Has col row ty
333 , GroupedBy tab col bys
334 , GroupedBy tab col bys
334 , tys ~ '[ty]
335 , tys ~ '[ty]
335 ) => IsLabel col
336 ) => IsLabel col
336− (NP (Expression ('Grouped bys) commons schemas params from) tys) where
337+ (NP (Expression outer ('Grouped bys) commons schemas params from) tys) where
337 fromLabel = fromLabel @col :* Nil
338 fromLabel = fromLabel @col :* Nil
339− ( HasUnique tab from row
340+ ( HasUnique tab (Join outer from) row
340 , Has col row ty
341 , Has col row ty
341 , GroupedBy tab col bys
342 , GroupedBy tab col bys
342 , column ~ (col ::: ty)
343 , column ~ (col ::: ty)
343 ) => IsLabel col
344 ) => IsLabel col
344− (Aliased (Expression ('Grouped bys) commons schemas params from) column) where
345+ (Aliased (Expression outer ('Grouped bys) commons schemas params from) column) where
345 fromLabel = fromLabel @col `As` Alias
346 fromLabel = fromLabel @col `As` Alias
347− ( HasUnique tab from row
348+ ( HasUnique tab (Join outer from) row
348 , Has col row ty
349 , Has col row ty
349 , GroupedBy tab col bys
350 , GroupedBy tab col bys
350 , columns ~ '[col ::: ty]
351 , columns ~ '[col ::: ty]
351 ) => IsLabel col
352 ) => IsLabel col
352− (NP (Aliased (Expression ('Grouped bys) commons schemas params from)) columns) where
353+ (NP (Aliased (Expression outer ('Grouped bys) commons schemas params from)) columns) where
353 fromLabel = fromLabel @col :* Nil
354 fromLabel = fromLabel @col :* Nil
356− ( Has tab from row
357+ ( Has tab (Join outer from) row
357 , Has col row ty
358 , Has col row ty
358 , GroupedBy tab col bys
359 , GroupedBy tab col bys
359 ) => IsQualified tab col
360 ) => IsQualified tab col
360− (Expression ('Grouped bys) commons schemas params from ty) where
361+ (Expression outer ('Grouped bys) commons schemas params from ty) where
361 tab ! col = UnsafeExpression $
362 tab ! col = UnsafeExpression $
362 renderSQL tab <> "." <> renderSQL col
363 renderSQL tab <> "." <> renderSQL col
364− ( Has tab from row
365+ ( Has tab (Join outer from) row
365 , Has col row ty
366 , Has col row ty
366 , GroupedBy tab col bys
367 , GroupedBy tab col bys
367 , tys ~ '[ty]
368 , tys ~ '[ty]
368 ) => IsQualified tab col
369 ) => IsQualified tab col
369− (NP (Expression ('Grouped bys) commons schemas params from) tys) where
370+ (NP (Expression outer ('Grouped bys) commons schemas params from) tys) where
370 tab ! col = tab ! col :* Nil
371 tab ! col = tab ! col :* Nil
372− ( Has tab from row
373+ ( Has tab (Join outer from) row
373 , Has col row ty
374 , Has col row ty
374 , GroupedBy tab col bys
375 , GroupedBy tab col bys
375 , column ~ (col ::: ty)
376 , column ~ (col ::: ty)
376 ) => IsQualified tab col
377 ) => IsQualified tab col
377− (Aliased (Expression ('Grouped bys) commons schemas params from) column) where
378+ (Aliased (Expression outer ('Grouped bys) commons schemas params from) column) where
378 tab ! col = tab ! col `As` col
379 tab ! col = tab ! col `As` col
380− ( Has tab from row
381+ ( Has tab (Join outer from) row
381 , Has col row ty
382 , Has col row ty
382 , GroupedBy tab col bys
383 , GroupedBy tab col bys
383 , columns ~ '[col ::: ty]
384 , columns ~ '[col ::: ty]
384 ) => IsQualified tab col
385 ) => IsQualified tab col
385− (NP (Aliased (Expression ('Grouped bys) commons schemas params from)) columns) where
386+ (NP (Aliased (Expression outer ('Grouped bys) commons schemas params from)) columns) where
386 tab ! col = tab ! col :* Nil
387 tab ! col = tab ! col :* Nil
388-- | analagous to `Nothing`
389-- | analagous to `Nothing`
390-- >>> printSQL null_
391-- >>> printSQL null_
392−null_ :: Expression commons schemas rels grouping params ('Null ty)
393+null_ :: Expression outer grp commons schemas params from ('Null ty)
393null_ = UnsafeExpression "NULL"
394null_ = UnsafeExpression "NULL"
395-- | analagous to `Just`
396-- | analagous to `Just`
@@ -397,8 +398,8 @@ null_ = UnsafeExpression "NULL"
397-- >>> printSQL $ notNull true
398-- >>> printSQL $ notNull true
400− :: Expression commons schemas rels grouping params ('NotNull ty)
401+ :: Expression outer grp commons schemas params from ('NotNull ty)
401− -> Expression commons schemas rels grouping params ('Null ty)
402+ -> Expression outer grp commons schemas params from ('Null ty)
402notNull = UnsafeExpression . renderSQL
403notNull = UnsafeExpression . renderSQL
404-- | return the leftmost value which is not NULL
405-- | return the leftmost value which is not NULL
@@ -406,11 +407,11 @@ notNull = UnsafeExpression . renderSQL
406-- >>> printSQL $ coalesce [null_, true] false
407-- >>> printSQL $ coalesce [null_, true] false
407-- COALESCE(NULL, TRUE, FALSE)
408-- COALESCE(NULL, TRUE, FALSE)
409− :: [Expression grp commons schemas params from ('Null ty)]
410+ :: [Expression outer grp commons schemas params from ('Null ty)]
410 -- ^ @NULL@s may be present
411 -- ^ @NULL@s may be present
411− -> Expression grp commons schemas params from ('NotNull ty)
412+ -> Expression outer grp commons schemas params from ('NotNull ty)
412 -- ^ @NULL@ is absent
413 -- ^ @NULL@ is absent
413− -> Expression grp commons schemas params from ('NotNull ty)
414+ -> Expression outer grp commons schemas params from ('NotNull ty)
414coalesce nullxs notNullx = UnsafeExpression $
415coalesce nullxs notNullx = UnsafeExpression $
415 "COALESCE" <> parenthesized (commaSeparated
416 "COALESCE" <> parenthesized (commaSeparated
416 ((renderSQL <$> nullxs) <> [renderSQL notNullx]))
417 ((renderSQL <$> nullxs) <> [renderSQL notNullx]))
@@ -420,26 +421,26 @@ coalesce nullxs notNullx = UnsafeExpression $
420-- >>> printSQL $ fromNull true null_
421-- >>> printSQL $ fromNull true null_
421-- COALESCE(NULL, TRUE)
422-- COALESCE(NULL, TRUE)
423− :: Expression grp commons schemas params from ('NotNull ty)
424+ :: Expression outer grp commons schemas params from ('NotNull ty)
424 -- ^ what to convert @NULL@ to
425 -- ^ what to convert @NULL@ to
425− -> Expression grp commons schemas params from ('Null ty)
426+ -> Expression outer grp commons schemas params from ('Null ty)
426− -> Expression grp commons schemas params from ('NotNull ty)
427+ -> Expression outer grp commons schemas params from ('NotNull ty)
427fromNull notNullx nullx = coalesce [nullx] notNullx
428fromNull notNullx nullx = coalesce [nullx] notNullx
429-- | >>> printSQL $ null_ & isNull
430-- | >>> printSQL $ null_ & isNull
430-- NULL IS NULL
431-- NULL IS NULL
432− :: Expression grp commons schemas params from ('Null ty)
433+ :: Expression outer grp commons schemas params from ('Null ty)
433 -- ^ possibly @NULL@
434 -- ^ possibly @NULL@
434− -> Condition grp commons schemas params from
435+ -> Condition outer grp commons schemas params from
435isNull x = UnsafeExpression $ renderSQL x <+> "IS NULL"
436isNull x = UnsafeExpression $ renderSQL x <+> "IS NULL"
437-- | >>> printSQL $ null_ & isNotNull
438-- | >>> printSQL $ null_ & isNotNull
438-- NULL IS NOT NULL
439-- NULL IS NOT NULL
440− :: Expression grp commons schemas params from ('Null ty)
441+ :: Expression outer grp commons schemas params from ('Null ty)
441 -- ^ possibly @NULL@
442 -- ^ possibly @NULL@
442− -> Condition grp commons schemas params from
443+ -> Condition outer grp commons schemas params from
443isNotNull x = UnsafeExpression $ renderSQL x <+> "IS NOT NULL"
444isNotNull x = UnsafeExpression $ renderSQL x <+> "IS NOT NULL"
445-- | analagous to `maybe` using @IS NULL@
446-- | analagous to `maybe` using @IS NULL@
@@ -447,13 +448,13 @@ isNotNull x = UnsafeExpression $ renderSQL x <+> "IS NOT NULL"
447-- >>> printSQL $ matchNull true not_ null_
448-- >>> printSQL $ matchNull true not_ null_
448-- CASE WHEN NULL IS NULL THEN TRUE ELSE (NOT NULL) END
449-- CASE WHEN NULL IS NULL THEN TRUE ELSE (NOT NULL) END
450− :: Expression grp commons schemas params from (nullty)
451+ :: Expression outer grp commons schemas params from (nullty)
451 -- ^ what to convert @NULL@ to
452 -- ^ what to convert @NULL@ to
452− -> ( Expression grp commons schemas params from ('NotNull ty)
453+ -> ( Expression outer grp commons schemas params from ('NotNull ty)
453− -> Expression grp commons schemas params from (nullty) )
454+ -> Expression outer grp commons schemas params from (nullty) )
454 -- ^ function to perform when @NULL@ is absent
455 -- ^ function to perform when @NULL@ is absent
455− -> Expression grp commons schemas params from ('Null ty)
456+ -> Expression outer grp commons schemas params from ('Null ty)
456− -> Expression grp commons schemas params from (nullty)
457+ -> Expression outer grp commons schemas params from (nullty)
457matchNull y f x = ifThenElse (isNull x) y
458matchNull y f x = ifThenElse (isNull x) y
458 (f (UnsafeExpression (renderSQL x)))
459 (f (UnsafeExpression (renderSQL x)))
@@ -461,25 +462,25 @@ matchNull y f x = ifThenElse (isNull x) y
461`nullIf` gives @NULL@.
462`nullIf` gives @NULL@.
463>>> :set -XTypeApplications -XDataKinds
464>>> :set -XTypeApplications -XDataKinds
464−>>> let expr = nullIf false (param @1) :: Expression grp commons schemas '[ 'NotNull 'PGbool] from ('Null 'PGbool)
465+>>> let expr = nullIf false (param @1) :: Expression outer grp commons schemas '[ 'NotNull 'PGbool] from ('Null 'PGbool)
465>>> printSQL expr
466>>> printSQL expr
466NULL IF (FALSE, ($1 :: bool))
467NULL IF (FALSE, ($1 :: bool))
469− :: Expression grp commons schemas params from ('NotNull ty)
470+ :: Expression outer grp commons schemas params from ('NotNull ty)
470 -- ^ @NULL@ is absent
471 -- ^ @NULL@ is absent
471− -> Expression grp commons schemas params from ('NotNull ty)
472+ -> Expression outer grp commons schemas params from ('NotNull ty)
472 -- ^ @NULL@ is absent
473 -- ^ @NULL@ is absent
473− -> Expression grp commons schemas params from ('Null ty)
474+ -> Expression outer grp commons schemas params from ('Null ty)
474nullIf x y = UnsafeExpression $ "NULL IF" <+> parenthesized
475nullIf x y = UnsafeExpression $ "NULL IF" <+> parenthesized
475 (renderSQL x <> ", " <> renderSQL y)
476 (renderSQL x <> ", " <> renderSQL y)
477-- | >>> printSQL $ array [null_, false, true]
478-- | >>> printSQL $ array [null_, false, true]
478-- ARRAY[NULL, FALSE, TRUE]
479-- ARRAY[NULL, FALSE, TRUE]
480− :: [Expression grp commons schemas params from ty]
481+ :: [Expression outer grp commons schemas params from ty]
481 -- ^ array elements
482 -- ^ array elements
482− -> Expression grp commons schemas params from (nullity ('PGvararray ty))
483+ -> Expression outer grp commons schemas params from (nullity ('PGvararray ty))
483array xs = UnsafeExpression $
484array xs = UnsafeExpression $
484 "ARRAY[" <> commaSeparated (renderSQL <$> xs) <> "]"
485 "ARRAY[" <> commaSeparated (renderSQL <$> xs) <> "]"
@@ -487,13 +488,13 @@ array xs = UnsafeExpression $
487-- (ARRAY[NULL, FALSE, TRUE])[2]
488-- (ARRAY[NULL, FALSE, TRUE])[2]
489 :: Word64 -- ^ index
490 :: Word64 -- ^ index
490− -> Expression grp commons schemas params from (nullity ('PGvararray ty)) -- ^ array
491+ -> Expression outer grp commons schemas params from (nullity ('PGvararray ty)) -- ^ array
491− -> Expression grp commons schemas params from (NullifyType ty)
492+ -> Expression outer grp commons schemas params from (NullifyType ty)
492index n expr = UnsafeExpression $
493index n expr = UnsafeExpression $
493 parenthesized (renderSQL expr) <> "[" <> fromString (show n) <> "]"
494 parenthesized (renderSQL expr) <> "[" <> fromString (show n) <> "]"
495instance (KnownSymbol label, label `In` labels) => IsPGlabel label
496instance (KnownSymbol label, label `In` labels) => IsPGlabel label
496− (Expression grp commons schemas params from (nullity ('PGenum labels))) where
497+ (Expression outer grp commons schemas params from (nullity ('PGenum labels))) where
497 label = UnsafeExpression $ renderSQL (PGlabel @label)
498 label = UnsafeExpression $ renderSQL (PGlabel @label)
499-- | A row constructor is an expression that builds a row value
500-- | A row constructor is an expression that builds a row value
@@ -505,14 +506,14 @@ instance (KnownSymbol label, label `In` labels) => IsPGlabel label
505-- , "imaginary" ::: 'NotNull 'PGfloat8 ]
506-- , "imaginary" ::: 'NotNull 'PGfloat8 ]
508−-- >>> let i = row (0 `as` #real :* 1 `as` #imaginary) :: Expression grp commons schemas params from ('NotNull Complex)
509+-- >>> let i = row (0 `as` #real :* 1 `as` #imaginary) :: Expression outer grp commons schemas params from ('NotNull Complex)
509-- >>> printSQL i
510-- >>> printSQL i
510-- ROW(0, 1)
511-- ROW(0, 1)
512 :: SListI row
513 :: SListI row
513− => NP (Aliased (Expression grp commons schemas params from)) row
514+ => NP (Aliased (Expression outer grp commons schemas params from)) row
514 -- ^ zero or more expressions for the row field values
515 -- ^ zero or more expressions for the row field values
515− -> Expression grp commons schemas params from (nullity ('PGcomposite row))
516+ -> Expression outer grp commons schemas params from (nullity ('PGcomposite row))
516row exprs = UnsafeExpression $ "ROW" <> parenthesized
517row exprs = UnsafeExpression $ "ROW" <> parenthesized
517 (renderCommaSeparated (\ (expr `As` _) -> renderSQL expr) exprs)
518 (renderCommaSeparated (\ (expr `As` _) -> renderSQL expr) exprs)
@@ -523,7 +524,7 @@ row exprs = UnsafeExpression $ "ROW" <> parenthesized
523-- type Schema = '["complex" ::: 'Typedef Complex]
524-- type Schema = '["complex" ::: 'Typedef Complex]
526−-- >>> let i = row (0 `as` #real :* 1 `as` #imaginary) :: Expression grp '[] (Public Schema) from params ('NotNull Complex)
527+-- >>> let i = row (0 `as` #real :* 1 `as` #imaginary) :: Expression outer grp '[] (Public Schema) from params ('NotNull Complex)
527-- >>> printSQL $ i & field #complex #imaginary
528-- >>> printSQL $ i & field #complex #imaginary
528-- (ROW(0, 1)::"complex")."imaginary"
529-- (ROW(0, 1)::"complex")."imaginary"
@@ -532,41 +533,41 @@ field
532 , Has field row ty)
533 , Has field row ty)
533 => QualifiedAlias sch tydef -- ^ row type
534 => QualifiedAlias sch tydef -- ^ row type
534 -> Alias field -- ^ field name
535 -> Alias field -- ^ field name
535− -> Expression grp commons schemas params from ('NotNull ('PGcomposite row))
536+ -> Expression outer grp commons schemas params from ('NotNull ('PGcomposite row))
536− -> Expression grp commons schemas params from ty
537+ -> Expression outer grp commons schemas params from ty
537field td fld expr = UnsafeExpression $
538field td fld expr = UnsafeExpression $
538 parenthesized (renderSQL expr <> "::" <> renderSQL td)
539 parenthesized (renderSQL expr <> "::" <> renderSQL td)
539 <> "." <> renderSQL fld
540 <> "." <> renderSQL fld
541instance Semigroup
542instance Semigroup
542− (Expression grp commons schemas params from (nullity ('PGvararray ty))) where
543+ (Expression outer grp commons schemas params from (nullity ('PGvararray ty))) where
543 (<>) = unsafeBinaryOp "||"
544 (<>) = unsafeBinaryOp "||"
545instance Monoid
546instance Monoid
546− (Expression grp commons schemas params from (nullity ('PGvararray ty))) where
547+ (Expression outer grp commons schemas params from (nullity ('PGvararray ty))) where
547 mempty = array []
548 mempty = array []
548 mappend = (<>)
549 mappend = (<>)
550−-- | >>> let expr = greatest currentTimestamp [param @1] :: Expression grp commons schemas '[ 'NotNull 'PGtimestamptz] from ('NotNull 'PGtimestamptz)
551+-- | >>> let expr = greatest currentTimestamp [param @1] :: Expression outer grp commons schemas '[ 'NotNull 'PGtimestamptz] from ('NotNull 'PGtimestamptz)
551-- >>> printSQL expr
552-- >>> printSQL expr
552-- GREATEST(CURRENT_TIMESTAMP, ($1 :: timestamp with time zone))
553-- GREATEST(CURRENT_TIMESTAMP, ($1 :: timestamp with time zone))
554− :: Expression grp commons schemas params from (nullty)
555+ :: Expression outer grp commons schemas params from (nullty)
555 -- ^ needs at least 1 argument
556 -- ^ needs at least 1 argument
556− -> [Expression grp commons schemas params from (nullty)]
557+ -> [Expression outer grp commons schemas params from (nullty)]
557 -- ^ or more
558 -- ^ or more
558− -> Expression grp commons schemas params from (nullty)
559+ -> Expression outer grp commons schemas params from (nullty)
559greatest x xs = UnsafeExpression $ "GREATEST("
560greatest x xs = UnsafeExpression $ "GREATEST("
560 <> commaSeparated (renderSQL <$> (x:xs)) <> ")"
561 <> commaSeparated (renderSQL <$> (x:xs)) <> ")"
562-- | >>> printSQL $ least currentTimestamp [null_]
563-- | >>> printSQL $ least currentTimestamp [null_]
563-- LEAST(CURRENT_TIMESTAMP, NULL)
564-- LEAST(CURRENT_TIMESTAMP, NULL)
565− :: Expression grp commons schemas params from (nullty)
566+ :: Expression outer grp commons schemas params from (nullty)
566 -- ^ needs at least 1 argument
567 -- ^ needs at least 1 argument
567− -> [Expression grp commons schemas params from (nullty)]
568+ -> [Expression outer grp commons schemas params from (nullty)]
568 -- ^ or more
569 -- ^ or more
569− -> Expression grp commons schemas params from (nullty)
570+ -> Expression outer grp commons schemas params from (nullty)
570least x xs = UnsafeExpression $ "LEAST("
571least x xs = UnsafeExpression $ "LEAST("
571 <> commaSeparated (renderSQL <$> (x:xs)) <> ")"
572 <> commaSeparated (renderSQL <$> (x:xs)) <> ")"
@@ -575,9 +576,9 @@ least x xs = UnsafeExpression $ "LEAST("
575unsafeBinaryOp
576unsafeBinaryOp
576 :: ByteString
577 :: ByteString
577 -- ^ operator
578 -- ^ operator
578− -> Expression grp commons schemas params from (ty0)
579+ -> Expression outer grp commons schemas params from (ty0)
579− -> Expression grp commons schemas params from (ty1)
580+ -> Expression outer grp commons schemas params from (ty1)
580− -> Expression grp commons schemas params from (ty2)
581+ -> Expression outer grp commons schemas params from (ty2)
581unsafeBinaryOp op x y = UnsafeExpression $ parenthesized $
582unsafeBinaryOp op x y = UnsafeExpression $ parenthesized $
582 renderSQL x <+> op <+> renderSQL y
583 renderSQL x <+> op <+> renderSQL y
@@ -586,8 +587,8 @@ unsafeBinaryOp op x y = UnsafeExpression $ parenthesized $
586unsafeUnaryOp
587unsafeUnaryOp
587 :: ByteString
588 :: ByteString
588 -- ^ operator
589 -- ^ operator
589− -> Expression grp commons schemas params from (ty0)
590+ -> Expression outer grp commons schemas params from (ty0)
590− -> Expression grp commons schemas params from (ty1)
591+ -> Expression outer grp commons schemas params from (ty1)
591unsafeUnaryOp op x = UnsafeExpression $ parenthesized $
592unsafeUnaryOp op x = UnsafeExpression $ parenthesized $
592 op <+> renderSQL x
593 op <+> renderSQL x
@@ -596,8 +597,8 @@ unsafeUnaryOp op x = UnsafeExpression $ parenthesized $
596unsafeFunction
597unsafeFunction
597 :: ByteString
598 :: ByteString
598 -- ^ function
599 -- ^ function
599− -> Expression grp commons schemas params from (xty)
600+ -> Expression outer grp commons schemas params from (xty)
600− -> Expression grp commons schemas params from (yty)
601+ -> Expression outer grp commons schemas params from (yty)
601unsafeFunction fun x = UnsafeExpression $
602unsafeFunction fun x = UnsafeExpression $
602 fun <> parenthesized (renderSQL x)
603 fun <> parenthesized (renderSQL x)
@@ -606,13 +607,13 @@ unsafeVariadicFunction
606 :: SListI elems
607 :: SListI elems
607 => ByteString
608 => ByteString
608 -- ^ function
609 -- ^ function
609− -> NP (Expression grp commons schemas params from) elems
610+ -> NP (Expression outer grp commons schemas params from) elems
610− -> Expression grp commons schemas params from ret
611+ -> Expression outer grp commons schemas params from ret
611unsafeVariadicFunction fun x = UnsafeExpression $
612unsafeVariadicFunction fun x = UnsafeExpression $
612 fun <> parenthesized (commaSeparated (hcollapse (hmap (K . renderSQL) x)))
613 fun <> parenthesized (commaSeparated (hcollapse (hmap (K . renderSQL) x)))
614instance ty `In` PGNum
615instance ty `In` PGNum
615− => Num (Expression grp commons schemas params from (nullity ty)) where
616+ => Num (Expression outer grp commons schemas params from (nullity ty)) where
616 (+) = unsafeBinaryOp "+"
617 (+) = unsafeBinaryOp "+"
617 (-) = unsafeBinaryOp "-"
618 (-) = unsafeBinaryOp "-"
618 (*) = unsafeBinaryOp "*"
619 (*) = unsafeBinaryOp "*"
@@ -624,12 +625,12 @@ instance ty `In` PGNum
626instance (ty `In` PGNum, ty `In` PGFloating) => Fractional
627instance (ty `In` PGNum, ty `In` PGFloating) => Fractional
627− (Expression grp commons schemas params from (nullity ty)) where
628+ (Expression outer grp commons schemas params from (nullity ty)) where
628 (/) = unsafeBinaryOp "/"
629 (/) = unsafeBinaryOp "/"
629 fromRational x = fromInteger (numerator x) / fromInteger (denominator x)
630 fromRational x = fromInteger (numerator x) / fromInteger (denominator x)
631instance (ty `In` PGNum, ty `In` PGFloating) => Floating
632instance (ty `In` PGNum, ty `In` PGFloating) => Floating
632− (Expression grp commons schemas params from (nullity ty)) where
633+ (Expression outer grp commons schemas params from (nullity ty)) where
633 pi = UnsafeExpression "pi()"
634 pi = UnsafeExpression "pi()"
634 exp = unsafeFunction "exp"
635 exp = unsafeFunction "exp"
635 log = unsafeFunction "ln"
636 log = unsafeFunction "ln"
@@ -652,18 +653,18 @@ instance (ty `In` PGNum, ty `In` PGFloating) => Floating
653-- | >>> :{
654-- | >>> :{
655−-- expression :: Expression grp commons schemas params from (nullity 'PGfloat4)
656+-- expression :: Expression outer grp commons schemas params from (nullity 'PGfloat4)
656-- expression = atan2_ pi 2
657-- expression = atan2_ pi 2
657-- in printSQL expression
658-- in printSQL expression
659-- atan2(pi(), 2)
660-- atan2(pi(), 2)
661 :: float `In` PGFloating
662 :: float `In` PGFloating
662− => Expression grp commons schemas params from (nullity float)
663+ => Expression outer grp commons schemas params from (nullity float)
663 -- ^ numerator
664 -- ^ numerator
664− -> Expression grp commons schemas params from (nullity float)
665+ -> Expression outer grp commons schemas params from (nullity float)
665 -- ^ denominator
666 -- ^ denominator
666− -> Expression grp commons schemas params from (nullity float)
667+ -> Expression outer grp commons schemas params from (nullity float)
667atan2_ y x = UnsafeExpression $
668atan2_ y x = UnsafeExpression $
668 "atan2(" <> renderSQL y <> ", " <> renderSQL x <> ")"
669 "atan2(" <> renderSQL y <> ", " <> renderSQL x <> ")"
@@ -676,9 +677,9 @@ atan2_ y x = UnsafeExpression $
677 :: TypeExpression schemas ty1
678 :: TypeExpression schemas ty1
678 -- ^ type to cast as
679 -- ^ type to cast as
679− -> Expression grp commons schemas params from ty0
680+ -> Expression outer grp commons schemas params from ty0
680 -- ^ value to convert
681 -- ^ value to convert
681− -> Expression grp commons schemas params from ty1
682+ -> Expression outer grp commons schemas params from ty1
682cast ty x = UnsafeExpression $ parenthesized $
683cast ty x = UnsafeExpression $ parenthesized $
683 renderSQL x <+> "::" <+> renderSQL ty
684 renderSQL x <+> "::" <+> renderSQL ty
@@ -686,136 +687,136 @@ cast ty x = UnsafeExpression $ parenthesized $
689−-- expression :: Expression grp commons schemas params from (nullity 'PGint2)
690+-- expression :: Expression outer grp commons schemas params from (nullity 'PGint2)
690-- expression = 5 `quot_` 2
691-- expression = 5 `quot_` 2
691-- in printSQL expression
692-- in printSQL expression
693-- (5 / 2)
694-- (5 / 2)
695 :: int `In` PGIntegral
696 :: int `In` PGIntegral
696− => Expression grp commons schemas params from (nullity int)
697+ => Expression outer grp commons schemas params from (nullity int)
697 -- ^ numerator
698 -- ^ numerator
698− -> Expression grp commons schemas params from (nullity int)
699+ -> Expression outer grp commons schemas params from (nullity int)
699 -- ^ denominator
700 -- ^ denominator
700− -> Expression grp commons schemas params from (nullity int)
701+ -> Expression outer grp commons schemas params from (nullity int)
701quot_ = unsafeBinaryOp "/"
702quot_ = unsafeBinaryOp "/"
703-- | remainder upon integer division
704-- | remainder upon integer division
707−-- expression :: Expression grp commons schemas params from (nullity 'PGint2)
708+-- expression :: Expression outer grp commons schemas params from (nullity 'PGint2)
708-- expression = 5 `rem_` 2
709-- expression = 5 `rem_` 2
709-- in printSQL expression
710-- in printSQL expression
711-- (5 % 2)
712-- (5 % 2)
713 :: int `In` PGIntegral
714 :: int `In` PGIntegral
714− => Expression grp commons schemas params from (nullity int)
715+ => Expression outer grp commons schemas params from (nullity int)
715 -- ^ numerator
716 -- ^ numerator
716− -> Expression grp commons schemas params from (nullity int)
717+ -> Expression outer grp commons schemas params from (nullity int)
717 -- ^ denominator
718 -- ^ denominator
718− -> Expression grp commons schemas params from (nullity int)
719+ -> Expression outer grp commons schemas params from (nullity int)
719rem_ = unsafeBinaryOp "%"
720rem_ = unsafeBinaryOp "%"
721-- | >>> :{
722-- | >>> :{
723−-- expression :: Expression grp commons schemas params from (nullity 'PGfloat4)
724+-- expression :: Expression outer grp commons schemas params from (nullity 'PGfloat4)
724-- expression = trunc pi
725-- expression = trunc pi
725-- in printSQL expression
726-- in printSQL expression
727-- trunc(pi())
728-- trunc(pi())
729 :: frac `In` PGFloating
730 :: frac `In` PGFloating
730− => Expression grp commons schemas params from (nullity frac)
731+ => Expression outer grp commons schemas params from (nullity frac)
731 -- ^ fractional number
732 -- ^ fractional number
732− -> Expression grp commons schemas params from (nullity frac)
733+ -> Expression outer grp commons schemas params from (nullity frac)
733trunc = unsafeFunction "trunc"
734trunc = unsafeFunction "trunc"
735-- | >>> :{
736-- | >>> :{
737−-- expression :: Expression grp commons schemas params from (nullity 'PGfloat4)
738+-- expression :: Expression outer grp commons schemas params from (nullity 'PGfloat4)
738-- expression = round_ pi
739-- expression = round_ pi
739-- in printSQL expression
740-- in printSQL expression
741-- round(pi())
742-- round(pi())
743 :: frac `In` PGFloating
744 :: frac `In` PGFloating
744− => Expression grp commons schemas params from (nullity frac)
745+ => Expression outer grp commons schemas params from (nullity frac)
745 -- ^ fractional number
746 -- ^ fractional number
746− -> Expression grp commons schemas params from (nullity frac)
747+ -> Expression outer grp commons schemas params from (nullity frac)
747round_ = unsafeFunction "round"
748round_ = unsafeFunction "round"
749-- | >>> :{
750-- | >>> :{
751−-- expression :: Expression grp commons schemas params from (nullity 'PGfloat4)
752+-- expression :: Expression outer grp commons schemas params from (nullity 'PGfloat4)
752-- expression = ceiling_ pi
753-- expression = ceiling_ pi
753-- in printSQL expression
754-- in printSQL expression
755-- ceiling(pi())
756-- ceiling(pi())
757 :: frac `In` PGFloating
758 :: frac `In` PGFloating
758− => Expression grp commons schemas params from (nullity frac)
759+ => Expression outer grp commons schemas params from (nullity frac)
759 -- ^ fractional number
760 -- ^ fractional number
760− -> Expression grp commons schemas params from (nullity frac)
761+ -> Expression outer grp commons schemas params from (nullity frac)
761ceiling_ = unsafeFunction "ceiling"
762ceiling_ = unsafeFunction "ceiling"
763-- | A `Condition` is an `Expression`, which can evaluate
764-- | A `Condition` is an `Expression`, which can evaluate
764-- to `true`, `false` or `null_`. This is because SQL uses
765-- to `true`, `false` or `null_`. This is because SQL uses
765-- a three valued logic.
766-- a three valued logic.
766−type Condition grp commons schemas params from =
767+type Condition outer grp commons schemas params from =
767− Expression grp commons schemas params from ('Null 'PGbool)
768+ Expression outer grp commons schemas params from ('Null 'PGbool)
769-- | >>> printSQL true
770-- | >>> printSQL true
771−true :: Expression grp commons schemas params from (nullity 'PGbool)
772+true :: Expression outer grp commons schemas params from (nullity 'PGbool)
772true = UnsafeExpression "TRUE"
773true = UnsafeExpression "TRUE"
774-- | >>> printSQL false
775-- | >>> printSQL false
776−false :: Expression grp commons schemas params from (nullity 'PGbool)
777+false :: Expression outer grp commons schemas params from (nullity 'PGbool)
777false = UnsafeExpression "FALSE"
778false = UnsafeExpression "FALSE"
779-- | >>> printSQL $ not_ true
780-- | >>> printSQL $ not_ true
780-- (NOT TRUE)
781-- (NOT TRUE)
782− :: Expression grp commons schemas params from (nullity 'PGbool)
783+ :: Expression outer grp commons schemas params from (nullity 'PGbool)
783− -> Expression grp commons schemas params from (nullity 'PGbool)
784+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
784not_ = unsafeUnaryOp "NOT"
785not_ = unsafeUnaryOp "NOT"
786-- | >>> printSQL $ true .&& false
787-- | >>> printSQL $ true .&& false
787-- (TRUE AND FALSE)
788-- (TRUE AND FALSE)
789− :: Expression grp commons schemas params from (nullity 'PGbool)
790+ :: Expression outer grp commons schemas params from (nullity 'PGbool)
790− -> Expression grp commons schemas params from (nullity 'PGbool)
791+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
791− -> Expression grp commons schemas params from (nullity 'PGbool)
792+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
792infixr 3 .&&
793infixr 3 .&&
793(.&&) = unsafeBinaryOp "AND"
794(.&&) = unsafeBinaryOp "AND"
795-- | >>> printSQL $ true .|| false
796-- | >>> printSQL $ true .|| false
796-- (TRUE OR FALSE)
797-- (TRUE OR FALSE)
798− :: Expression grp commons schemas params from (nullity 'PGbool)
799+ :: Expression outer grp commons schemas params from (nullity 'PGbool)
799− -> Expression grp commons schemas params from (nullity 'PGbool)
800+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
800− -> Expression grp commons schemas params from (nullity 'PGbool)
801+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
801infixr 2 .||
802infixr 2 .||
802(.||) = unsafeBinaryOp "OR"
803(.||) = unsafeBinaryOp "OR"
804-- | >>> :{
805-- | >>> :{
806−-- expression :: Expression grp commons schemas params from (nullity 'PGint2)
807+-- expression :: Expression outer grp commons schemas params from (nullity 'PGint2)
807-- expression = caseWhenThenElse [(true, 1), (false, 2)] 3
808-- expression = caseWhenThenElse [(true, 1), (false, 2)] 3
808-- in printSQL expression
809-- in printSQL expression
810-- CASE WHEN TRUE THEN 1 WHEN FALSE THEN 2 ELSE 3 END
811-- CASE WHEN TRUE THEN 1 WHEN FALSE THEN 2 ELSE 3 END
811caseWhenThenElse
812caseWhenThenElse
812− :: [ ( Condition grp commons schemas params from
813+ :: [ ( Condition outer grp commons schemas params from
813− , Expression grp commons schemas params from ty
814+ , Expression outer grp commons schemas params from ty
815 -- ^ whens and thens
816 -- ^ whens and thens
816− -> Expression grp commons schemas params from ty
817+ -> Expression outer grp commons schemas params from ty
817 -- ^ else
818 -- ^ else
818− -> Expression grp commons schemas params from ty
819+ -> Expression outer grp commons schemas params from ty
819caseWhenThenElse whenThens else_ = UnsafeExpression $ mconcat
820caseWhenThenElse whenThens else_ = UnsafeExpression $ mconcat
821 , mconcat
822 , mconcat
@@ -831,16 +832,16 @@ caseWhenThenElse whenThens else_ = UnsafeExpression $ mconcat
832-- | >>> :{
833-- | >>> :{
834−-- expression :: Expression grp commons schemas params from (nullity 'PGint2)
835+-- expression :: Expression outer grp commons schemas params from (nullity 'PGint2)
835-- expression = ifThenElse true 1 0
836-- expression = ifThenElse true 1 0
836-- in printSQL expression
837-- in printSQL expression
838-- CASE WHEN TRUE THEN 1 ELSE 0 END
839-- CASE WHEN TRUE THEN 1 ELSE 0 END
839ifThenElse
840ifThenElse
840− :: Condition grp commons schemas params from
841+ :: Condition outer grp commons schemas params from
841− -> Expression grp commons schemas params from ty -- ^ then
842+ -> Expression outer grp commons schemas params from ty -- ^ then
842− -> Expression grp commons schemas params from ty -- ^ else
843+ -> Expression outer grp commons schemas params from ty -- ^ else
843− -> Expression grp commons schemas params from ty
844+ -> Expression outer grp commons schemas params from ty
844ifThenElse if_ then_ else_ = caseWhenThenElse [(if_,then_)] else_
845ifThenElse if_ then_ else_ = caseWhenThenElse [(if_,then_)] else_
846-- | Comparison operations like `.==`, `./=`, `.>`, `.>=`, `.<` and `.<=`
847-- | Comparison operations like `.==`, `./=`, `.>`, `.>=`, `.<` and `.<=`
@@ -849,85 +850,85 @@ ifThenElse if_ then_ else_ = caseWhenThenElse [(if_,then_)] else_
849-- >>> printSQL $ true .== null_
850-- >>> printSQL $ true .== null_
850-- (TRUE = NULL)
851-- (TRUE = NULL)
852− :: Expression grp commons schemas params from (nullity0 ty) -- ^ lhs
853+ :: Expression outer grp commons schemas params from (nullity0 ty) -- ^ lhs
853− -> Expression grp commons schemas params from (nullity1 ty) -- ^ rhs
854+ -> Expression outer grp commons schemas params from (nullity1 ty) -- ^ rhs
854− -> Condition grp commons schemas params from
855+ -> Condition outer grp commons schemas params from
855(.==) = unsafeBinaryOp "="
856(.==) = unsafeBinaryOp "="
856infix 4 .==
857infix 4 .==
858-- | >>> printSQL $ true ./= null_
859-- | >>> printSQL $ true ./= null_
859-- (TRUE <> NULL)
860-- (TRUE <> NULL)
861− :: Expression grp commons schemas params from (nullity0 ty) -- ^ lhs
862+ :: Expression outer grp commons schemas params from (nullity0 ty) -- ^ lhs
862− -> Expression grp commons schemas params from (nullity1 ty) -- ^ rhs
863+ -> Expression outer grp commons schemas params from (nullity1 ty) -- ^ rhs
863− -> Condition grp commons schemas params from
864+ -> Condition outer grp commons schemas params from
864(./=) = unsafeBinaryOp "<>"
865(./=) = unsafeBinaryOp "<>"
865infix 4 ./=
866infix 4 ./=
867-- | >>> printSQL $ true .>= null_
868-- | >>> printSQL $ true .>= null_
868-- (TRUE >= NULL)
869-- (TRUE >= NULL)
870− :: Expression grp commons schemas params from (nullity0 ty) -- ^ lhs
871+ :: Expression outer grp commons schemas params from (nullity0 ty) -- ^ lhs
871− -> Expression grp commons schemas params from (nullity1 ty) -- ^ rhs
872+ -> Expression outer grp commons schemas params from (nullity1 ty) -- ^ rhs
872− -> Condition grp commons schemas params from
873+ -> Condition outer grp commons schemas params from
873(.>=) = unsafeBinaryOp ">="
874(.>=) = unsafeBinaryOp ">="
874infix 4 .>=
875infix 4 .>=
876-- | >>> printSQL $ true .< null_
877-- | >>> printSQL $ true .< null_
877-- (TRUE < NULL)
878-- (TRUE < NULL)
879− :: Expression grp commons schemas params from (nullity0 ty) -- ^ lhs
880+ :: Expression outer grp commons schemas params from (nullity0 ty) -- ^ lhs
880− -> Expression grp commons schemas params from (nullity1 ty) -- ^ rhs
881+ -> Expression outer grp commons schemas params from (nullity1 ty) -- ^ rhs
881− -> Condition grp commons schemas params from
882+ -> Condition outer grp commons schemas params from
882(.<) = unsafeBinaryOp "<"
883(.<) = unsafeBinaryOp "<"
883infix 4 .<
884infix 4 .<
885-- | >>> printSQL $ true .<= null_
886-- | >>> printSQL $ true .<= null_
886-- (TRUE <= NULL)
887-- (TRUE <= NULL)
888− :: Expression grp commons schemas params from (nullity0 ty) -- ^ lhs
889+ :: Expression outer grp commons schemas params from (nullity0 ty) -- ^ lhs
889− -> Expression grp commons schemas params from (nullity1 ty) -- ^ rhs
890+ -> Expression outer grp commons schemas params from (nullity1 ty) -- ^ rhs
890− -> Condition grp commons schemas params from
891+ -> Condition outer grp commons schemas params from
891(.<=) = unsafeBinaryOp "<="
892(.<=) = unsafeBinaryOp "<="
892infix 4 .<=
893infix 4 .<=
894-- | >>> printSQL $ true .> null_
895-- | >>> printSQL $ true .> null_
895-- (TRUE > NULL)
896-- (TRUE > NULL)
897− :: Expression grp commons schemas params from (nullity0 ty) -- ^ lhs
898+ :: Expression outer grp commons schemas params from (nullity0 ty) -- ^ lhs
898− -> Expression grp commons schemas params from (nullity1 ty) -- ^ rhs
899+ -> Expression outer grp commons schemas params from (nullity1 ty) -- ^ rhs
899− -> Condition grp commons schemas params from
900+ -> Condition outer grp commons schemas params from
900(.>) = unsafeBinaryOp ">"
901(.>) = unsafeBinaryOp ">"
901infix 4 .>
902infix 4 .>
903-- | >>> printSQL currentDate
904-- | >>> printSQL currentDate
904-- CURRENT_DATE
905-- CURRENT_DATE
905currentDate
906currentDate
906− :: Expression grp commons schemas params from (nullity 'PGdate)
907+ :: Expression outer grp commons schemas params from (nullity 'PGdate)
907currentDate = UnsafeExpression "CURRENT_DATE"
908currentDate = UnsafeExpression "CURRENT_DATE"
909-- | >>> printSQL currentTime
910-- | >>> printSQL currentTime
910-- CURRENT_TIME
911-- CURRENT_TIME
911currentTime
912currentTime
912− :: Expression grp commons schemas params from (nullity 'PGtimetz)
913+ :: Expression outer grp commons schemas params from (nullity 'PGtimetz)
913currentTime = UnsafeExpression "CURRENT_TIME"
914currentTime = UnsafeExpression "CURRENT_TIME"
915-- | >>> printSQL currentTimestamp
916-- | >>> printSQL currentTimestamp
916-- CURRENT_TIMESTAMP
917-- CURRENT_TIMESTAMP
917currentTimestamp
918currentTimestamp
918− :: Expression grp commons schemas params from (nullity 'PGtimestamptz)
919+ :: Expression outer grp commons schemas params from (nullity 'PGtimestamptz)
919currentTimestamp = UnsafeExpression "CURRENT_TIMESTAMP"
920currentTimestamp = UnsafeExpression "CURRENT_TIMESTAMP"
921-- | >>> printSQL localTime
922-- | >>> printSQL localTime
922-- LOCALTIME
923-- LOCALTIME
924− :: Expression grp commons schemas params from (nullity 'PGtime)
925+ :: Expression outer grp commons schemas params from (nullity 'PGtime)
925localTime = UnsafeExpression "LOCALTIME"
926localTime = UnsafeExpression "LOCALTIME"
927-- | >>> printSQL localTimestamp
928-- | >>> printSQL localTimestamp
928-- LOCALTIMESTAMP
929-- LOCALTIMESTAMP
929localTimestamp
930localTimestamp
930− :: Expression grp commons schemas params from (nullity 'PGtimestamp)
931+ :: Expression outer grp commons schemas params from (nullity 'PGtimestamp)
931localTimestamp = UnsafeExpression "LOCALTIMESTAMP"
932localTimestamp = UnsafeExpression "LOCALTIMESTAMP"
933{-----------------------------------------
934{-----------------------------------------
@@ -935,7 +936,7 @@ text
935-----------------------------------------}
936-----------------------------------------}
937instance IsString
938instance IsString
938− (Expression grp commons schemas params from (nullity 'PGtext)) where
939+ (Expression outer grp commons schemas params from (nullity 'PGtext)) where
939 fromString str = UnsafeExpression $
940 fromString str = UnsafeExpression $
940 "E\'" <> fromString (escape =<< str) <> "\'"
941 "E\'" <> fromString (escape =<< str) <> "\'"
@@ -951,36 +952,36 @@ instance IsString
953instance Semigroup
954instance Semigroup
954− (Expression grp commons schemas params from (nullity 'PGtext)) where
955+ (Expression outer grp commons schemas params from (nullity 'PGtext)) where
955 (<>) = unsafeBinaryOp "||"
956 (<>) = unsafeBinaryOp "||"
957instance Monoid
958instance Monoid
958− (Expression grp commons schemas params from (nullity 'PGtext)) where
959+ (Expression outer grp commons schemas params from (nullity 'PGtext)) where
959 mempty = fromString ""
960 mempty = fromString ""
960 mappend = (<>)
961 mappend = (<>)
962-- | >>> printSQL $ lower "ARRRGGG"
963-- | >>> printSQL $ lower "ARRRGGG"
963-- lower(E'ARRRGGG')
964-- lower(E'ARRRGGG')
965− :: Expression grp commons schemas params from (nullity 'PGtext)
966+ :: Expression outer grp commons schemas params from (nullity 'PGtext)
966 -- ^ string to lower case
967 -- ^ string to lower case
967− -> Expression grp commons schemas params from (nullity 'PGtext)
968+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
968lower = unsafeFunction "lower"
969lower = unsafeFunction "lower"
970-- | >>> printSQL $ upper "eeee"
971-- | >>> printSQL $ upper "eeee"
971-- upper(E'eeee')
972-- upper(E'eeee')
973− :: Expression grp commons schemas params from (nullity 'PGtext)
974+ :: Expression outer grp commons schemas params from (nullity 'PGtext)
974 -- ^ string to upper case
975 -- ^ string to upper case
975− -> Expression grp commons schemas params from (nullity 'PGtext)
976+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
976upper = unsafeFunction "upper"
977upper = unsafeFunction "upper"
978-- | >>> printSQL $ charLength "four"
979-- | >>> printSQL $ charLength "four"
979-- char_length(E'four')
980-- char_length(E'four')
980charLength
981charLength
981− :: Expression grp commons schemas params from (nullity 'PGtext)
982+ :: Expression outer grp commons schemas params from (nullity 'PGtext)
982 -- ^ string to measure
983 -- ^ string to measure
983− -> Expression grp commons schemas params from (nullity 'PGint4)
984+ -> Expression outer grp commons schemas params from (nullity 'PGint4)
984charLength = unsafeFunction "char_length"
985charLength = unsafeFunction "char_length"
986-- | The `like` expression returns true if the @string@ matches
987-- | The `like` expression returns true if the @string@ matches
@@ -993,11 +994,11 @@ charLength = unsafeFunction "char_length"
993-- >>> printSQL $ "abc" `like` "a%"
994-- >>> printSQL $ "abc" `like` "a%"
994-- (E'abc' LIKE E'a%')
995-- (E'abc' LIKE E'a%')
996− :: Expression grp commons schemas params from (nullity 'PGtext)
997+ :: Expression outer grp commons schemas params from (nullity 'PGtext)
997 -- ^ string
998 -- ^ string
998− -> Expression grp commons schemas params from (nullity 'PGtext)
999+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
999 -- ^ pattern
1000 -- ^ pattern
1000− -> Expression grp commons schemas params from (nullity 'PGbool)
1001+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
1001like = unsafeBinaryOp "LIKE"
1002like = unsafeBinaryOp "LIKE"
1003-- | The key word ILIKE can be used instead of LIKE to make the
1004-- | The key word ILIKE can be used instead of LIKE to make the
@@ -1006,11 +1007,11 @@ like = unsafeBinaryOp "LIKE"
1006-- >>> printSQL $ "abc" `ilike` "a%"
1007-- >>> printSQL $ "abc" `ilike` "a%"
1007-- (E'abc' ILIKE E'a%')
1008-- (E'abc' ILIKE E'a%')
1009− :: Expression grp commons schemas params from (nullity 'PGtext)
1010+ :: Expression outer grp commons schemas params from (nullity 'PGtext)
1010 -- ^ string
1011 -- ^ string
1011− -> Expression grp commons schemas params from (nullity 'PGtext)
1012+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
1012 -- ^ pattern
1013 -- ^ pattern
1013− -> Expression grp commons schemas params from (nullity 'PGbool)
1014+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
1014ilike = unsafeBinaryOp "ILIKE"
1015ilike = unsafeBinaryOp "ILIKE"
1016{-----------------------------------------
1017{-----------------------------------------
@@ -1025,36 +1026,36 @@ Table 9.44: json and jsonb operators
1025-- | Get JSON value (object field or array element) at a key.
1026-- | Get JSON value (object field or array element) at a key.
1027 :: (json `In` PGJsonType, key `In` PGJsonKey)
1028 :: (json `In` PGJsonType, key `In` PGJsonKey)
1028− => Expression grp commons schemas params from (nullity json)
1029+ => Expression outer grp commons schemas params from (nullity json)
1029− -> Expression grp commons schemas params from (nullity key)
1030+ -> Expression outer grp commons schemas params from (nullity key)
1030− -> Expression grp commons schemas params from ('Null json)
1031+ -> Expression outer grp commons schemas params from ('Null json)
1031infixl 8 .->
1032infixl 8 .->
1032(.->) = unsafeBinaryOp "->"
1033(.->) = unsafeBinaryOp "->"
1034-- | Get JSON value (object field or array element) at a key, as text.
1035-- | Get JSON value (object field or array element) at a key, as text.
1036 :: (json `In` PGJsonType, key `In` PGJsonKey)
1037 :: (json `In` PGJsonType, key `In` PGJsonKey)
1037− => Expression grp commons schemas params from (nullity json)
1038+ => Expression outer grp commons schemas params from (nullity json)
1038− -> Expression grp commons schemas params from (nullity key)
1039+ -> Expression outer grp commons schemas params from (nullity key)
1039− -> Expression grp commons schemas params from ('Null 'PGtext)
1040+ -> Expression outer grp commons schemas params from ('Null 'PGtext)
1040infixl 8 .->>
1041infixl 8 .->>
1041(.->>) = unsafeBinaryOp "->>"
1042(.->>) = unsafeBinaryOp "->>"
1043-- | Get JSON value at a specified path.
1044-- | Get JSON value at a specified path.
1045 :: (json `In` PGJsonType, PGTextArray "(.#>)" path)
1046 :: (json `In` PGJsonType, PGTextArray "(.#>)" path)
1046− => Expression grp commons schemas params from (nullity json)
1047+ => Expression outer grp commons schemas params from (nullity json)
1047− -> Expression grp commons schemas params from (nullity path)
1048+ -> Expression outer grp commons schemas params from (nullity path)
1048− -> Expression grp commons schemas params from ('Null json)
1049+ -> Expression outer grp commons schemas params from ('Null json)
1049infixl 8 .#>
1050infixl 8 .#>
1050(.#>) = unsafeBinaryOp "#>"
1051(.#>) = unsafeBinaryOp "#>"
1052-- | Get JSON value at a specified path as text.
1053-- | Get JSON value at a specified path as text.
1054 :: (json `In` PGJsonType, PGTextArray "(.#>>)" path)
1055 :: (json `In` PGJsonType, PGTextArray "(.#>>)" path)
1055− => Expression grp commons schemas params from (nullity json)
1056+ => Expression outer grp commons schemas params from (nullity json)
1056− -> Expression grp commons schemas params from (nullity path)
1057+ -> Expression outer grp commons schemas params from (nullity path)
1057− -> Expression grp commons schemas params from ('Null 'PGtext)
1058+ -> Expression outer grp commons schemas params from ('Null 'PGtext)
1058infixl 8 .#>>
1059infixl 8 .#>>
1059(.#>>) = unsafeBinaryOp "#>>"
1060(.#>>) = unsafeBinaryOp "#>>"
@@ -1063,49 +1064,49 @@ infixl 8 .#>>
1063-- | Does the left JSON value contain the right JSON path/value entries at the
1064-- | Does the left JSON value contain the right JSON path/value entries at the
1064-- top level?
1065-- top level?
1066− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1067+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1067− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1068+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1068− -> Condition grp commons schemas params from
1069+ -> Condition outer grp commons schemas params from
1069infixl 9 .@>
1070infixl 9 .@>
1070(.@>) = unsafeBinaryOp "@>"
1071(.@>) = unsafeBinaryOp "@>"
1072-- | Are the left JSON path/value entries contained at the top level within the
1073-- | Are the left JSON path/value entries contained at the top level within the
1073-- right JSON value?
1074-- right JSON value?
1075− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1076+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1076− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1077+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1077− -> Condition grp commons schemas params from
1078+ -> Condition outer grp commons schemas params from
1078infixl 9 .<@
1079infixl 9 .<@
1079(.<@) = unsafeBinaryOp "<@"
1080(.<@) = unsafeBinaryOp "<@"
1081-- | Does the string exist as a top-level key within the JSON value?
1082-- | Does the string exist as a top-level key within the JSON value?
1083− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1084+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1084− -> Expression grp commons schemas params from (nullity 'PGtext)
1085+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
1085− -> Condition grp commons schemas params from
1086+ -> Condition outer grp commons schemas params from
1086infixl 9 .?
1087infixl 9 .?
1087(.?) = unsafeBinaryOp "?"
1088(.?) = unsafeBinaryOp "?"
1089-- | Do any of these array strings exist as top-level keys?
1090-- | Do any of these array strings exist as top-level keys?
1091− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1092+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1092− -> Expression grp commons schemas params from (nullity ('PGvararray ('NotNull 'PGtext)))
1093+ -> Expression outer grp commons schemas params from (nullity ('PGvararray ('NotNull 'PGtext)))
1093− -> Condition grp commons schemas params from
1094+ -> Condition outer grp commons schemas params from
1094infixl 9 .?|
1095infixl 9 .?|
1095(.?|) = unsafeBinaryOp "?|"
1096(.?|) = unsafeBinaryOp "?|"
1097-- | Do all of these array strings exist as top-level keys?
1098-- | Do all of these array strings exist as top-level keys?
1099− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1100+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1100− -> Expression grp commons schemas params from (nullity ('PGvararray ('NotNull 'PGtext)))
1101+ -> Expression outer grp commons schemas params from (nullity ('PGvararray ('NotNull 'PGtext)))
1101− -> Condition grp commons schemas params from
1102+ -> Condition outer grp commons schemas params from
1102infixl 9 .?&
1103infixl 9 .?&
1103(.?&) = unsafeBinaryOp "?&"
1104(.?&) = unsafeBinaryOp "?&"
1105-- | Concatenate two jsonb values into a new jsonb value.
1106-- | Concatenate two jsonb values into a new jsonb value.
1106−instance
1107+instance Semigroup
1107− Semigroup (Expression commons schemas from grouping param (nullity 'PGjsonb)) where
1108+ (Expression outer grp commons schemas params from (nullity 'PGjsonb)) where
1108− (<>) = unsafeBinaryOp "||"
1109+ (<>) = unsafeBinaryOp "||"
1110-- | Delete a key or keys from a JSON object, or remove an array element.
1111-- | Delete a key or keys from a JSON object, or remove an array element.
@@ -1121,9 +1122,9 @@ instance
1121-- count from the end). Throws an error if top level container is not an array.
1122-- count from the end). Throws an error if top level container is not an array.
1123 :: (key `In` '[ 'PGtext, 'PGvararray ('NotNull 'PGtext), 'PGint4, 'PGint2 ]) -- hlint error without parens here
1124 :: (key `In` '[ 'PGtext, 'PGvararray ('NotNull 'PGtext), 'PGint4, 'PGint2 ]) -- hlint error without parens here
1124− => Expression grp commons schemas params from (nullity 'PGjsonb)
1125+ => Expression outer grp commons schemas params from (nullity 'PGjsonb)
1125− -> Expression grp commons schemas params from (nullity key)
1126+ -> Expression outer grp commons schemas params from (nullity key)
1126− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1127+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1127infixl 6 .-.
1128infixl 6 .-.
1128(.-.) = unsafeBinaryOp "-"
1129(.-.) = unsafeBinaryOp "-"
@@ -1131,9 +1132,9 @@ infixl 6 .-.
1131-- integers count from the end)
1132-- integers count from the end)
1133 :: PGTextArray "(#-.)" arrayty
1134 :: PGTextArray "(#-.)" arrayty
1134− => Expression grp commons schemas params from (nullity 'PGjsonb)
1135+ => Expression outer grp commons schemas params from (nullity 'PGjsonb)
1135− -> Expression grp commons schemas params from (nullity arrayty)
1136+ -> Expression outer grp commons schemas params from (nullity arrayty)
1136− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1137+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1137infixl 6 #-.
1138infixl 6 #-.
1138(#-.) = unsafeBinaryOp "#-"
1139(#-.) = unsafeBinaryOp "#-"
@@ -1144,14 +1145,14 @@ Table 9.45: JSON creation functions
1144-- | Literal binary JSON
1145-- | Literal binary JSON
1146 :: JSON.ToJSON x
1147 :: JSON.ToJSON x
1147− => x -> Expression grp commons schemas params from (nullity 'PGjsonb)
1148+ => x -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1148jsonbLit = cast jsonb . UnsafeExpression
1149jsonbLit = cast jsonb . UnsafeExpression
1149 . singleQuotedUtf8 . toStrict . JSON.encode
1150 . singleQuotedUtf8 . toStrict . JSON.encode
1151-- | Literal JSON
1152-- | Literal JSON
1153 :: JSON.ToJSON x
1154 :: JSON.ToJSON x
1154− => x -> Expression grp commons schemas params from (nullity 'PGjson)
1155+ => x -> Expression outer grp commons schemas params from (nullity 'PGjson)
1155jsonLit = cast json . UnsafeExpression
1156jsonLit = cast json . UnsafeExpression
1156 . singleQuotedUtf8 . toStrict . JSON.encode
1157 . singleQuotedUtf8 . toStrict . JSON.encode
@@ -1162,8 +1163,8 @@ jsonLit = cast json . UnsafeExpression
1162-- number, a Boolean, or a null value, the text representation will be used, in
1163-- number, a Boolean, or a null value, the text representation will be used, in
1163-- such a fashion that it is a valid json value.
1164-- such a fashion that it is a valid json value.
1165− :: Expression grp commons schemas params from (nullity ty)
1166+ :: Expression outer grp commons schemas params from (nullity ty)
1166− -> Expression grp commons schemas params from (nullity 'PGjson)
1167+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
1167toJson = unsafeFunction "to_json"
1168toJson = unsafeFunction "to_json"
1169-- | Returns the value as jsonb. Arrays and composites are converted
1170-- | Returns the value as jsonb. Arrays and composites are converted
@@ -1173,43 +1174,43 @@ toJson = unsafeFunction "to_json"
1173-- number, a Boolean, or a null value, the text representation will be used, in
1174-- number, a Boolean, or a null value, the text representation will be used, in
1174-- such a fashion that it is a valid jsonb value.
1175-- such a fashion that it is a valid jsonb value.
1176− :: Expression grp commons schemas params from (nullity ty)
1177+ :: Expression outer grp commons schemas params from (nullity ty)
1177− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1178+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1178toJsonb = unsafeFunction "to_jsonb"
1179toJsonb = unsafeFunction "to_jsonb"
1180-- | Returns the array as a JSON array. A PostgreSQL multidimensional array
1181-- | Returns the array as a JSON array. A PostgreSQL multidimensional array
1181-- becomes a JSON array of arrays.
1182-- becomes a JSON array of arrays.
1182arrayToJson
1183arrayToJson
1183 :: PGArray "arrayToJson" arr
1184 :: PGArray "arrayToJson" arr
1184− => Expression grp commons schemas params from (nullity arr)
1185+ => Expression outer grp commons schemas params from (nullity arr)
1185− -> Expression grp commons schemas params from (nullity 'PGjson)
1186+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
1186arrayToJson = unsafeFunction "array_to_json"
1187arrayToJson = unsafeFunction "array_to_json"
1188-- | Returns the row as a JSON object.
1189-- | Returns the row as a JSON object.
1189rowToJson
1190rowToJson
1190− :: Expression grp commons schemas params from (nullity ('PGcomposite ty))
1191+ :: Expression outer grp commons schemas params from (nullity ('PGcomposite ty))
1191− -> Expression grp commons schemas params from (nullity 'PGjson)
1192+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
1192rowToJson = unsafeFunction "row_to_json"
1193rowToJson = unsafeFunction "row_to_json"
1194-- | Builds a possibly-heterogeneously-typed JSON array out of a variadic
1195-- | Builds a possibly-heterogeneously-typed JSON array out of a variadic
1195-- argument list.
1196-- argument list.
1196jsonBuildArray
1197jsonBuildArray
1197 :: SListI elems
1198 :: SListI elems
1198− => NP (Expression grp commons schemas params from) elems
1199+ => NP (Expression outer grp commons schemas params from) elems
1199− -> Expression grp commons schemas params from (nullity 'PGjson)
1200+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
1200jsonBuildArray = unsafeVariadicFunction "json_build_array"
1201jsonBuildArray = unsafeVariadicFunction "json_build_array"
1202-- | Builds a possibly-heterogeneously-typed (binary) JSON array out of a
1203-- | Builds a possibly-heterogeneously-typed (binary) JSON array out of a
1203-- variadic argument list.
1204-- variadic argument list.
1204jsonbBuildArray
1205jsonbBuildArray
1205 :: SListI elems
1206 :: SListI elems
1206− => NP (Expression grp commons schemas params from) elems
1207+ => NP (Expression outer grp commons schemas params from) elems
1207− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1208+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1208jsonbBuildArray = unsafeVariadicFunction "jsonb_build_array"
1209jsonbBuildArray = unsafeVariadicFunction "jsonb_build_array"
1210unsafeRowFunction
1211unsafeRowFunction
1211 :: All Top elems
1212 :: All Top elems
1212− => NP (Aliased (Expression grp commons schemas params from)) elems
1213+ => NP (Aliased (Expression outer grp commons schemas params from)) elems
1213 -> [ByteString]
1214 -> [ByteString]
1214unsafeRowFunction =
1215unsafeRowFunction =
1215 (`appEndo` []) . hcfoldMap (Proxy :: Proxy Top)
1216 (`appEndo` []) . hcfoldMap (Proxy :: Proxy Top)
@@ -1224,8 +1225,8 @@ unsafeRowFunction =
1224-- and values.
1225-- and values.
1225jsonBuildObject
1226jsonBuildObject
1226 :: All Top elems
1227 :: All Top elems
1227− => NP (Aliased (Expression grp commons schemas params from)) elems
1228+ => NP (Aliased (Expression outer grp commons schemas params from)) elems
1228− -> Expression grp commons schemas params from (nullity 'PGjson)
1229+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
1229jsonBuildObject
1230jsonBuildObject
1230 = unsafeFunction "json_build_object"
1231 = unsafeFunction "json_build_object"
1231 . UnsafeExpression
1232 . UnsafeExpression
@@ -1237,8 +1238,8 @@ jsonBuildObject
1237-- between text and values.
1238-- between text and values.
1238jsonbBuildObject
1239jsonbBuildObject
1239 :: All Top elems
1240 :: All Top elems
1240− => NP (Aliased (Expression grp commons schemas params from)) elems
1241+ => NP (Aliased (Expression outer grp commons schemas params from)) elems
1241− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1242+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1242jsonbBuildObject
1243jsonbBuildObject
1243 = unsafeFunction "jsonb_build_object"
1244 = unsafeFunction "jsonb_build_object"
1244 . UnsafeExpression
1245 . UnsafeExpression
@@ -1251,8 +1252,8 @@ jsonbBuildObject
1251-- array has exactly two elements, which are taken as a key/value pair.
1252-- array has exactly two elements, which are taken as a key/value pair.
1252jsonObject
1253jsonObject
1253 :: PGArrayOf "jsonObject" arr ('NotNull 'PGtext)
1254 :: PGArrayOf "jsonObject" arr ('NotNull 'PGtext)
1254− => Expression grp commons schemas params from (nullity arr)
1255+ => Expression outer grp commons schemas params from (nullity arr)
1255− -> Expression grp commons schemas params from (nullity 'PGjson)
1256+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
1256jsonObject = unsafeFunction "json_object"
1257jsonObject = unsafeFunction "json_object"
1258-- | Builds a binary JSON object out of a text array. The array must have either
1259-- | Builds a binary JSON object out of a text array. The array must have either
@@ -1261,8 +1262,8 @@ jsonObject = unsafeFunction "json_object"
1261-- array has exactly two elements, which are taken as a key/value pair.
1262-- array has exactly two elements, which are taken as a key/value pair.
1262jsonbObject
1263jsonbObject
1263 :: PGArrayOf "jsonbObject" arr ('NotNull 'PGtext)
1264 :: PGArrayOf "jsonbObject" arr ('NotNull 'PGtext)
1264− => Expression grp commons schemas params from (nullity arr)
1265+ => Expression outer grp commons schemas params from (nullity arr)
1265− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1266+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1266jsonbObject = unsafeFunction "jsonb_object"
1267jsonbObject = unsafeFunction "jsonb_object"
1268-- | This is an alternate form of 'jsonObject' that takes two arrays; one for
1269-- | This is an alternate form of 'jsonObject' that takes two arrays; one for
@@ -1270,9 +1271,9 @@ jsonbObject = unsafeFunction "jsonb_object"
1270jsonZipObject
1271jsonZipObject
1271 :: ( PGArrayOf "jsonZipObject" keysArray ('NotNull 'PGtext)
1272 :: ( PGArrayOf "jsonZipObject" keysArray ('NotNull 'PGtext)
1272 , PGArrayOf "jsonZipObject" valuesArray ('NotNull 'PGtext))
1273 , PGArrayOf "jsonZipObject" valuesArray ('NotNull 'PGtext))
1273− => Expression grp commons schemas params from (nullity keysArray)
1274+ => Expression outer grp commons schemas params from (nullity keysArray)
1274− -> Expression grp commons schemas params from (nullity valuesArray)
1275+ -> Expression outer grp commons schemas params from (nullity valuesArray)
1275− -> Expression grp commons schemas params from (nullity 'PGjson)
1276+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
1276jsonZipObject ks vs =
1277jsonZipObject ks vs =
1277 unsafeVariadicFunction "json_object" (ks :* vs :* Nil)
1278 unsafeVariadicFunction "json_object" (ks :* vs :* Nil)
@@ -1282,9 +1283,9 @@ jsonZipObject ks vs =
1282jsonbZipObject
1283jsonbZipObject
1283 :: ( PGArrayOf "jsonbZipObject" keysArray ('NotNull 'PGtext)
1284 :: ( PGArrayOf "jsonbZipObject" keysArray ('NotNull 'PGtext)
1284 , PGArrayOf "jsonbZipObject" valuesArray ('NotNull 'PGtext))
1285 , PGArrayOf "jsonbZipObject" valuesArray ('NotNull 'PGtext))
1285− => Expression grp commons schemas params from (nullity keysArray)
1286+ => Expression outer grp commons schemas params from (nullity keysArray)
1286− -> Expression grp commons schemas params from (nullity valuesArray)
1287+ -> Expression outer grp commons schemas params from (nullity valuesArray)
1287− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1288+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1288jsonbZipObject ks vs =
1289jsonbZipObject ks vs =
1289 unsafeVariadicFunction "jsonb_object" (ks :* vs :* Nil)
1290 unsafeVariadicFunction "jsonb_object" (ks :* vs :* Nil)
@@ -1294,23 +1295,23 @@ Table 9.46: JSON processing functions
1295-- | Returns the number of elements in the outermost JSON array.
1296-- | Returns the number of elements in the outermost JSON array.
1296jsonArrayLength
1297jsonArrayLength
1297− :: Expression grp commons schemas params from (nullity 'PGjson)
1298+ :: Expression outer grp commons schemas params from (nullity 'PGjson)
1298− -> Expression grp commons schemas params from (nullity 'PGint4)
1299+ -> Expression outer grp commons schemas params from (nullity 'PGint4)
1299jsonArrayLength = unsafeFunction "json_array_length"
1300jsonArrayLength = unsafeFunction "json_array_length"
1301-- | Returns the number of elements in the outermost binary JSON array.
1302-- | Returns the number of elements in the outermost binary JSON array.
1302jsonbArrayLength
1303jsonbArrayLength
1303− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1304+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1304− -> Expression grp commons schemas params from (nullity 'PGint4)
1305+ -> Expression outer grp commons schemas params from (nullity 'PGint4)
1305jsonbArrayLength = unsafeFunction "jsonb_array_length"
1306jsonbArrayLength = unsafeFunction "jsonb_array_length"
1307-- | Returns JSON value pointed to by the given path (equivalent to #>
1308-- | Returns JSON value pointed to by the given path (equivalent to #>
1308-- operator).
1309-- operator).
1309jsonExtractPath
1310jsonExtractPath
1310 :: SListI elems
1311 :: SListI elems
1311− => Expression grp commons schemas params from (nullity 'PGjson)
1312+ => Expression outer grp commons schemas params from (nullity 'PGjson)
1312− -> NP (Expression grp commons schemas params from) elems
1313+ -> NP (Expression outer grp commons schemas params from) elems
1313− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1314+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1314jsonExtractPath x xs =
1315jsonExtractPath x xs =
1315 unsafeVariadicFunction "json_extract_path" (x :* xs)
1316 unsafeVariadicFunction "json_extract_path" (x :* xs)
@@ -1318,9 +1319,9 @@ jsonExtractPath x xs =
1318-- operator).
1319-- operator).
1319jsonbExtractPath
1320jsonbExtractPath
1320 :: SListI elems
1321 :: SListI elems
1321− => Expression grp commons schemas params from (nullity 'PGjsonb)
1322+ => Expression outer grp commons schemas params from (nullity 'PGjsonb)
1322− -> NP (Expression grp commons schemas params from) elems
1323+ -> NP (Expression outer grp commons schemas params from) elems
1323− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1324+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1324jsonbExtractPath x xs =
1325jsonbExtractPath x xs =
1325 unsafeVariadicFunction "jsonb_extract_path" (x :* xs)
1326 unsafeVariadicFunction "jsonb_extract_path" (x :* xs)
@@ -1328,9 +1329,9 @@ jsonbExtractPath x xs =
1328-- operator), as text.
1329-- operator), as text.
1329jsonExtractPathAsText
1330jsonExtractPathAsText
1330 :: SListI elems
1331 :: SListI elems
1331− => Expression grp commons schemas params from (nullity 'PGjson)
1332+ => Expression outer grp commons schemas params from (nullity 'PGjson)
1332− -> NP (Expression grp commons schemas params from) elems
1333+ -> NP (Expression outer grp commons schemas params from) elems
1333− -> Expression grp commons schemas params from (nullity 'PGjson)
1334+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
1334jsonExtractPathAsText x xs =
1335jsonExtractPathAsText x xs =
1335 unsafeVariadicFunction "json_extract_path_text" (x :* xs)
1336 unsafeVariadicFunction "json_extract_path_text" (x :* xs)
@@ -1338,38 +1339,38 @@ jsonExtractPathAsText x xs =
1338-- operator), as text.
1339-- operator), as text.
1339jsonbExtractPathAsText
1340jsonbExtractPathAsText
1340 :: SListI elems
1341 :: SListI elems
1341− => Expression grp commons schemas params from (nullity 'PGjsonb)
1342+ => Expression outer grp commons schemas params from (nullity 'PGjsonb)
1342− -> NP (Expression grp commons schemas params from) elems
1343+ -> NP (Expression outer grp commons schemas params from) elems
1343− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1344+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1344jsonbExtractPathAsText x xs =
1345jsonbExtractPathAsText x xs =
1345 unsafeVariadicFunction "jsonb_extract_path_text" (x :* xs)
1346 unsafeVariadicFunction "jsonb_extract_path_text" (x :* xs)
1347-- | Returns the type of the outermost JSON value as a text string. Possible
1348-- | Returns the type of the outermost JSON value as a text string. Possible
1348-- types are object, array, string, number, boolean, and null.
1349-- types are object, array, string, number, boolean, and null.
1349jsonTypeof
1350jsonTypeof
1350− :: Expression grp commons schemas params from (nullity 'PGjson)
1351+ :: Expression outer grp commons schemas params from (nullity 'PGjson)
1351− -> Expression grp commons schemas params from (nullity 'PGtext)
1352+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
1352jsonTypeof = unsafeFunction "json_typeof"
1353jsonTypeof = unsafeFunction "json_typeof"
1354-- | Returns the type of the outermost binary JSON value as a text string.
1355-- | Returns the type of the outermost binary JSON value as a text string.
1355-- Possible types are object, array, string, number, boolean, and null.
1356-- Possible types are object, array, string, number, boolean, and null.
1356jsonbTypeof
1357jsonbTypeof
1357− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1358+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1358− -> Expression grp commons schemas params from (nullity 'PGtext)
1359+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
1359jsonbTypeof = unsafeFunction "jsonb_typeof"
1360jsonbTypeof = unsafeFunction "jsonb_typeof"
1361-- | Returns its argument with all object fields that have null values omitted.
1362-- | Returns its argument with all object fields that have null values omitted.
1362-- Other null values are untouched.
1363-- Other null values are untouched.
1363jsonStripNulls
1364jsonStripNulls
1364− :: Expression grp commons schemas params from (nullity 'PGjson)
1365+ :: Expression outer grp commons schemas params from (nullity 'PGjson)
1365− -> Expression grp commons schemas params from (nullity 'PGjson)
1366+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
1366jsonStripNulls = unsafeFunction "json_strip_nulls"
1367jsonStripNulls = unsafeFunction "json_strip_nulls"
1368-- | Returns its argument with all object fields that have null values omitted.
1369-- | Returns its argument with all object fields that have null values omitted.
1369-- Other null values are untouched.
1370-- Other null values are untouched.
1370jsonbStripNulls
1371jsonbStripNulls
1371− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1372+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1372− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1373+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1373jsonbStripNulls = unsafeFunction "jsonb_strip_nulls"
1374jsonbStripNulls = unsafeFunction "jsonb_strip_nulls"
1375-- | @ jsonbSet target path new_value create_missing @
1376-- | @ jsonbSet target path new_value create_missing @
@@ -1381,11 +1382,11 @@ jsonbStripNulls = unsafeFunction "jsonb_strip_nulls"
1381-- arrays.
1382-- arrays.
1383 :: PGTextArray "jsonbSet" arr
1384 :: PGTextArray "jsonbSet" arr
1384− => Expression grp commons schemas params from (nullity 'PGjsonb)
1385+ => Expression outer grp commons schemas params from (nullity 'PGjsonb)
1385− -> Expression grp commons schemas params from (nullity arr)
1386+ -> Expression outer grp commons schemas params from (nullity arr)
1386− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1387+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1387− -> Maybe (Expression grp commons schemas params from (nullity 'PGbool))
1388+ -> Maybe (Expression outer grp commons schemas params from (nullity 'PGbool))
1388− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1389+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1389jsonbSet tgt path val createMissing = case createMissing of
1390jsonbSet tgt path val createMissing = case createMissing of
1390 Just m -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* m :* Nil)
1391 Just m -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* m :* Nil)
1391 Nothing -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* Nil)
1392 Nothing -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* Nil)
@@ -1400,19 +1401,19 @@ jsonbSet tgt path val createMissing = case createMissing of
1400-- in path count from the end of JSON arrays.
1401-- in path count from the end of JSON arrays.
1401jsonbInsert
1402jsonbInsert
1402 :: PGTextArray "jsonbInsert" arr
1403 :: PGTextArray "jsonbInsert" arr
1403− => Expression grp commons schemas params from (nullity 'PGjsonb)
1404+ => Expression outer grp commons schemas params from (nullity 'PGjsonb)
1404− -> Expression grp commons schemas params from (nullity arr)
1405+ -> Expression outer grp commons schemas params from (nullity arr)
1405− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1406+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1406− -> Maybe (Expression grp commons schemas params from (nullity 'PGbool))
1407+ -> Maybe (Expression outer grp commons schemas params from (nullity 'PGbool))
1407− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1408+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1408jsonbInsert tgt path val insertAfter = case insertAfter of
1409jsonbInsert tgt path val insertAfter = case insertAfter of
1409 Just i -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* i :* Nil)
1410 Just i -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* i :* Nil)
1410 Nothing -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* Nil)
1411 Nothing -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* Nil)
1412-- | Returns its argument as indented JSON text.
1413-- | Returns its argument as indented JSON text.
1413jsonbPretty
1414jsonbPretty
1414− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1415+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1415− -> Expression grp commons schemas params from (nullity 'PGtext)
1416+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
1416jsonbPretty = unsafeFunction "jsonb_pretty"
1417jsonbPretty = unsafeFunction "jsonb_pretty"
1418{-----------------------------------------
1419{-----------------------------------------
@@ -1426,7 +1427,7 @@ class Aggregate expr1 expr2 aggr
1427 -- >>> :{
1428 -- >>> :{
1429− -- expression :: Expression (Grouped bys) commons schemas params from ('NotNull 'PGint8)
1430+ -- expression :: Expression '[] ('Grouped bys) commons schemas params from ('NotNull 'PGint8)
1430 -- expression = countStar
1431 -- expression = countStar
1431 -- in printSQL expression
1432 -- in printSQL expression
@@ -1435,7 +1436,7 @@ class Aggregate expr1 expr2 aggr
1436 -- | >>> :{
1437 -- | >>> :{
1438− -- expression :: Expression (Grouped bys) commons schemas params '[tab ::: '["col" ::: nullity ty]] ('NotNull 'PGint8)
1439+ -- expression :: Expression '[] ('Grouped bys) commons schemas params '[tab ::: '["col" ::: nullity ty]] ('NotNull 'PGint8)
1439 -- expression = count (All #col)
1440 -- expression = count (All #col)
1440 -- in printSQL expression
1441 -- in printSQL expression
@@ -1447,7 +1448,7 @@ class Aggregate expr1 expr2 aggr
1448 -- | >>> :{
1449 -- | >>> :{
1450− -- expression :: Expression ('Grouped bys) commons schemas params '[tab ::: '["col" ::: 'Null 'PGnumeric]] ('Null 'PGnumeric)
1451+ -- expression :: Expression '[] ('Grouped bys) commons schemas params '[tab ::: '["col" ::: 'Null 'PGnumeric]] ('Null 'PGnumeric)
1451 -- expression = sum_ (Distinct #col)
1452 -- expression = sum_ (Distinct #col)
1452 -- in printSQL expression
1453 -- in printSQL expression
@@ -1462,9 +1463,19 @@ class Aggregate expr1 expr2 aggr
1462 :: expr1 ty
1463 :: expr1 ty
1463 -> aggr ('NotNull ('PGvararray ty))
1464 -> aggr ('NotNull ('PGvararray ty))
1466+ -- | aggregates values as a JSON array
1469+ -> aggr ('NotNull 'PGjson)
1471+ -- | aggregates values as a JSON array
1474+ -> aggr ('NotNull 'PGjsonb)
1465 -- | >>> :{
1476 -- | >>> :{
1467− -- expression :: Expression ('Grouped bys) commons schemas params '[tab ::: '["col" ::: nullity 'PGint4]] (nullity 'PGint4)
1478+ -- expression :: Expression '[] ('Grouped bys) commons schemas params '[tab ::: '["col" ::: nullity 'PGint4]] (nullity 'PGint4)
1468 -- expression = bitAnd (Distinct #col)
1479 -- expression = bitAnd (Distinct #col)
1469 -- in printSQL expression
1480 -- in printSQL expression
@@ -1477,7 +1488,7 @@ class Aggregate expr1 expr2 aggr
1478 -- | >>> :{
1489 -- | >>> :{
1480− -- expression :: Expression ('Grouped bys) commons schemas params '[tab ::: '["col" ::: nullity 'PGint4]] (nullity 'PGint4)
1491+ -- expression :: Expression '[] ('Grouped bys) commons schemas params '[tab ::: '["col" ::: nullity 'PGint4]] (nullity 'PGint4)
1481 -- expression = bitOr (All #col)
1492 -- expression = bitOr (All #col)
1482 -- in printSQL expression
1493 -- in printSQL expression
@@ -1490,7 +1501,7 @@ class Aggregate expr1 expr2 aggr
1491 -- | >>> :{
1502 -- | >>> :{
1493− -- winFun :: WindowFunction 'Ungrouped commons schemas params '[tab ::: '["col" ::: nullity 'PGbool]] (nullity 'PGbool)
1504+ -- winFun :: WindowFunction '[] 'Ungrouped commons schemas params '[tab ::: '["col" ::: nullity 'PGbool]] (nullity 'PGbool)
1494 -- winFun = boolAnd #col
1505 -- winFun = boolAnd #col
1495 -- in printSQL winFun
1506 -- in printSQL winFun
@@ -1502,7 +1513,7 @@ class Aggregate expr1 expr2 aggr
1503 -- | >>> :{
1514 -- | >>> :{
1505− -- expression :: Expression (Grouped bys) commons schemas params '[tab ::: '["col" ::: nullity 'PGbool]] (nullity 'PGbool)
1516+ -- expression :: Expression '[] ('Grouped bys) commons schemas params '[tab ::: '["col" ::: nullity 'PGbool]] (nullity 'PGbool)
1506 -- expression = boolOr (All #col)
1517 -- expression = boolOr (All #col)
1507 -- in printSQL expression
1518 -- in printSQL expression
@@ -1516,7 +1527,7 @@ class Aggregate expr1 expr2 aggr
1517 -- >>> :{
1528 -- >>> :{
1519− -- expression :: Expression ('Grouped bys) commons schemas params '[tab ::: '["col" ::: nullity 'PGbool]] (nullity 'PGbool)
1530+ -- expression :: Expression '[] ('Grouped bys) commons schemas params '[tab ::: '["col" ::: nullity 'PGbool]] (nullity 'PGbool)
1520 -- expression = every (Distinct #col)
1531 -- expression = every (Distinct #col)
1521 -- in printSQL expression
1532 -- in printSQL expression
@@ -1537,7 +1548,7 @@ class Aggregate expr1 expr2 aggr
1537 :: expr1 (nullity ty)
1548 :: expr1 (nullity ty)
1538 -- ^ what to minimize
1549 -- ^ what to minimize
1539 -> aggr (nullity ty)
1550 -> aggr (nullity ty)
1541 -- | average aggregation
1552 -- | average aggregation
1543 :: expr1 (nullity ty)
1554 :: expr1 (nullity ty)
@@ -1547,7 +1558,7 @@ class Aggregate expr1 expr2 aggr
1547 {- | correlation coefficient
1558 {- | correlation coefficient
1550− expression :: Expression ('Grouped g) c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGfloat8)
1561+ expression :: Expression '[] ('Grouped g) c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGfloat8)
1551 expression = corr (All (#y :*: #x))
1562 expression = corr (All (#y :*: #x))
1552 in printSQL expression
1563 in printSQL expression
@@ -1560,7 +1571,7 @@ class Aggregate expr1 expr2 aggr
1560 {- | population covariance
1571 {- | population covariance
1563− expression :: Expression ('Grouped g) c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGfloat8)
1574+ expression :: Expression '[] ('Grouped g) c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGfloat8)
1564 expression = covarPop (All (#y :*: #x))
1575 expression = covarPop (All (#y :*: #x))
1565 in printSQL expression
1576 in printSQL expression
@@ -1573,7 +1584,7 @@ class Aggregate expr1 expr2 aggr
1573 {- | sample covariance
1584 {- | sample covariance
1576− winFun :: WindowFunction 'Ungrouped c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGfloat8)
1587+ winFun :: WindowFunction '[] 'Ungrouped c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGfloat8)
1577 winFun = covarSamp (#y :*: #x)
1588 winFun = covarSamp (#y :*: #x)
1578 in printSQL winFun
1589 in printSQL winFun
@@ -1586,7 +1597,7 @@ class Aggregate expr1 expr2 aggr
1586 {- | average of the independent variable (sum(X)/N)
1597 {- | average of the independent variable (sum(X)/N)
1589− expression :: Expression ('Grouped g) c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGfloat8)
1600+ expression :: Expression '[] ('Grouped g) c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGfloat8)
1590 expression = regrAvgX (All (#y :*: #x))
1601 expression = regrAvgX (All (#y :*: #x))
1591 in printSQL expression
1602 in printSQL expression
@@ -1599,7 +1610,7 @@ class Aggregate expr1 expr2 aggr
1599 {- | average of the dependent variable (sum(Y)/N)
1610 {- | average of the dependent variable (sum(Y)/N)
1602− winFun :: WindowFunction 'Ungrouped c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGfloat8)
1613+ winFun :: WindowFunction '[] 'Ungrouped c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGfloat8)
1603 winFun = regrAvgY (#y :*: #x)
1614 winFun = regrAvgY (#y :*: #x)
1604 in printSQL winFun
1615 in printSQL winFun
@@ -1612,7 +1623,7 @@ class Aggregate expr1 expr2 aggr
1612 {- | number of input rows in which both expressions are nonnull
1623 {- | number of input rows in which both expressions are nonnull
1615− winFun :: WindowFunction 'Ungrouped c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGint8)
1626+ winFun :: WindowFunction '[] 'Ungrouped c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGint8)
1616 winFun = regrCount (#y :*: #x)
1627 winFun = regrCount (#y :*: #x)
1617 in printSQL winFun
1628 in printSQL winFun
@@ -1625,7 +1636,7 @@ class Aggregate expr1 expr2 aggr
1625 {- | y-intercept of the least-squares-fit linear equation determined by the (X, Y) pairs
1636 {- | y-intercept of the least-squares-fit linear equation determined by the (X, Y) pairs
1628− expression :: Expression ('Grouped g) c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGfloat8)
1639+ expression :: Expression '[] ('Grouped g) c s p '[t ::: '["x" ::: 'NotNull 'PGfloat8, "y" ::: 'NotNull 'PGfloat8]] ('NotNull 'PGfloat8)
1629 expression = regrIntercept (All (#y :*: #x))
1640 expression = regrIntercept (All (#y :*: #x))
1630 in printSQL expression
1641 in printSQL expression
@@ -1663,27 +1674,27 @@ class Aggregate expr1 expr2 aggr
1664 :: expr2 (nullity 'PGfloat8)
1675 :: expr2 (nullity 'PGfloat8)
1665 -> aggr (nullity 'PGfloat8)
1676 -> aggr (nullity 'PGfloat8)
1667 -- | historical alias for `stddevSamp`
1678 -- | historical alias for `stddevSamp`
1669 :: expr1 (nullity ty)
1680 :: expr1 (nullity ty)
1670 -> aggr (nullity (PGAvg ty))
1681 -> aggr (nullity (PGAvg ty))
1672 -- | population standard deviation of the input values
1683 -- | population standard deviation of the input values
1673 stddevPop
1684 stddevPop
1674 :: expr1 (nullity ty)
1685 :: expr1 (nullity ty)
1675 -> aggr (nullity (PGAvg ty))
1686 -> aggr (nullity (PGAvg ty))
1677 -- | sample standard deviation of the input values
1688 -- | sample standard deviation of the input values
1678 stddevSamp
1689 stddevSamp
1679 :: expr1 (nullity ty)
1690 :: expr1 (nullity ty)
1680 -> aggr (nullity (PGAvg ty))
1691 -> aggr (nullity (PGAvg ty))
1682 -- | historical alias for `varSamp`
1693 -- | historical alias for `varSamp`
1683 variance
1694 variance
1684 :: expr1 (nullity ty)
1695 :: expr1 (nullity ty)
1685 -> aggr (nullity (PGAvg ty))
1696 -> aggr (nullity (PGAvg ty))
1687 -- | population variance of the input values
1698 -- | population variance of the input values
1688 -- (square of the population standard deviation)
1699 -- (square of the population standard deviation)
@@ -1700,16 +1711,16 @@ data Distinction expr ty
1700 = All (expr ty)
1711 = All (expr ty)
1701 | Distinct (expr ty)
1712 | Distinct (expr ty)
1702 deriving (GHC.Generic,Show,Eq,Ord)
1713 deriving (GHC.Generic,Show,Eq,Ord)
1703−instance NFData (Distinction (Expression grp commons schemas params from) ty)
1714+instance NFData (Distinction (Expression outer grp commons schemas params from) ty)
1704−instance RenderSQL (Distinction (Expression grp commons schemas params from) ty) where
1715+instance RenderSQL (Distinction (Expression outer grp commons schemas params from) ty) where
1705 renderSQL = \case
1716 renderSQL = \case
1706 All x -> "ALL" <+> renderSQL x
1717 All x -> "ALL" <+> renderSQL x
1707 Distinct x -> "DISTINCT" <+> renderSQL x
1718 Distinct x -> "DISTINCT" <+> renderSQL x
1708instance RenderSQL
1719instance RenderSQL
1709 (Distinction
1720 (Distinction
1710− ( Expression grp commons schemas params from
1721+ ( Expression outer grp commons schemas params from
1712− Expression grp commons schemas params from) xty ) where
1723+ Expression outer grp commons schemas params from) xty ) where
1713 renderSQL = \case
1724 renderSQL = \case
1714 All (x :*: x') ->
1725 All (x :*: x') ->
1715 "ALL" <+> renderSQL x <> ", " <> renderSQL x'
1726 "ALL" <+> renderSQL x <> ", " <> renderSQL x'
@@ -1717,13 +1728,15 @@ instance RenderSQL
1717 "DISTINCT" <+> renderSQL x <> ", " <> renderSQL x'
1728 "DISTINCT" <+> renderSQL x <> ", " <> renderSQL x'
1719instance Aggregate
1730instance Aggregate
1720− (Distinction (Expression 'Ungrouped commons schemas params from))
1731+ (Distinction (Expression outer 'Ungrouped commons schemas params from))
1721− (Distinction (Expression 'Ungrouped commons schemas params from :*: Expression 'Ungrouped commons schemas params from))
1732+ (Distinction (Expression outer 'Ungrouped commons schemas params from :*: Expression outer 'Ungrouped commons schemas params from))
1722− (Expression ('Grouped bys) commons schemas params from) where
1733+ (Expression outer ('Grouped bys) commons schemas params from) where
1723 countStar = UnsafeExpression "count(*)"
1734 countStar = UnsafeExpression "count(*)"
1724 count = unsafeAggregate1 "count"
1735 count = unsafeAggregate1 "count"
1725 sum_ = unsafeAggregate1 "sum"
1736 sum_ = unsafeAggregate1 "sum"
1726 arrayAgg = unsafeAggregate1 "array_agg"
1737 arrayAgg = unsafeAggregate1 "array_agg"
1738+ jsonAgg = unsafeAggregate1 "json_agg"
1739+ jsonbAgg = unsafeAggregate1 "jsonb_agg"
1727 bitAnd = unsafeAggregate1 "bit_and"
1740 bitAnd = unsafeAggregate1 "bit_and"
1728 bitOr = unsafeAggregate1 "bit_or"
1741 bitOr = unsafeAggregate1 "bit_or"
1729 boolAnd = unsafeAggregate1 "bool_and"
1742 boolAnd = unsafeAggregate1 "bool_and"
@@ -1751,13 +1764,15 @@ instance Aggregate
1751 varPop = unsafeAggregate1 "var_pop"
1764 varPop = unsafeAggregate1 "var_pop"
1752 varSamp = unsafeAggregate1 "var_samp"
1765 varSamp = unsafeAggregate1 "var_samp"
1753instance Aggregate
1766instance Aggregate
1754− (Expression grp commons schemas params from)
1767+ (Expression outer grp commons schemas params from)
1755− (Expression grp commons schemas params from :*: Expression grp commons schemas params from)
1768+ (Expression outer grp commons schemas params from :*: Expression outer grp commons schemas params from)
1756− (WindowFunction grp commons schemas params from) where
1769+ (WindowFunction outer grp commons schemas params from) where
1757 countStar = UnsafeWindowFunction "count(*)"
1770 countStar = UnsafeWindowFunction "count(*)"
1758 count = unsafeWindowFunction1 "count"
1771 count = unsafeWindowFunction1 "count"
1759 sum_ = unsafeWindowFunction1 "sum"
1772 sum_ = unsafeWindowFunction1 "sum"
1760 arrayAgg = unsafeWindowFunction1 "array_agg"
1773 arrayAgg = unsafeWindowFunction1 "array_agg"
1774+ jsonAgg = unsafeWindowFunction1 "json_agg"
1775+ jsonbAgg = unsafeWindowFunction1 "jsonb_agg"
1761 bitAnd = unsafeWindowFunction1 "bit_and"
1776 bitAnd = unsafeWindowFunction1 "bit_and"
1762 bitOr = unsafeWindowFunction1 "bit_or"
1777 bitOr = unsafeWindowFunction1 "bit_or"
1763 boolAnd = unsafeWindowFunction1 "bool_and"
1778 boolAnd = unsafeWindowFunction1 "bool_and"
@@ -1788,16 +1803,16 @@ instance Aggregate
1788-- | escape hatch to define aggregate functions
1803-- | escape hatch to define aggregate functions
1789unsafeAggregate1
1804unsafeAggregate1
1790 :: ByteString -- ^ aggregate function
1805 :: ByteString -- ^ aggregate function
1791− -> Distinction (Expression 'Ungrouped commons schemas params from) xty
1806+ -> Distinction (Expression outer 'Ungrouped commons schemas params from) xty
1792− -> Expression ('Grouped bys) commons schemas params from yty
1807+ -> Expression outer ('Grouped bys) commons schemas params from yty
1793unsafeAggregate1 fun x = UnsafeExpression $ mconcat
1808unsafeAggregate1 fun x = UnsafeExpression $ mconcat
1794 [fun, "(", renderSQL x, ")"]
1809 [fun, "(", renderSQL x, ")"]
1796-- | escape hatch to define aggregate binary functions
1811-- | escape hatch to define aggregate binary functions
1797unsafeAggregate2
1812unsafeAggregate2
1798 :: ByteString -- ^ aggregate function
1813 :: ByteString -- ^ aggregate function
1799− -> Distinction (Expression 'Ungrouped commons schemas params from :*: Expression 'Ungrouped commons schemas params from) xty
1814+ -> Distinction (Expression outer 'Ungrouped commons schemas params from :*: Expression outer 'Ungrouped commons schemas params from) xty
1800− -> Expression ('Grouped bys) commons schemas params from yty
1815+ -> Expression outer ('Grouped bys) commons schemas params from yty
1801unsafeAggregate2 fun xx = UnsafeExpression $ mconcat
1816unsafeAggregate2 fun xx = UnsafeExpression $ mconcat
1802 [fun, "(", renderSQL xx, ")"]
1817 [fun, "(", renderSQL xx, ")"]
@@ -1993,35 +2008,35 @@ Sorting
1993-- `AscNullsLast`, `DescNullsFirst` and `DescNullsLast` options are used to
2008-- `AscNullsLast`, `DescNullsFirst` and `DescNullsLast` options are used to
1994-- determine whether nulls appear before or after non-null values in the sort
2009-- determine whether nulls appear before or after non-null values in the sort
1995-- ordering of a `Null` result column.
2010-- ordering of a `Null` result column.
1996−data SortExpression grp commons schemas params from where
2011+data SortExpression outer grp commons schemas params from where
1998− :: Expression grp commons schemas params from ('NotNull ty)
2013+ :: Expression outer grp commons schemas params from ('NotNull ty)
1999− -> SortExpression grp commons schemas params from
2014+ -> SortExpression outer grp commons schemas params from
2001− :: Expression grp commons schemas params from ('NotNull ty)
2016+ :: Expression outer grp commons schemas params from ('NotNull ty)
2002− -> SortExpression grp commons schemas params from
2017+ -> SortExpression outer grp commons schemas params from
2003 AscNullsFirst
2018 AscNullsFirst
2004− :: Expression grp commons schemas params from ('Null ty)
2019+ :: Expression outer grp commons schemas params from ('Null ty)
2005− -> SortExpression grp commons schemas params from
2020+ -> SortExpression outer grp commons schemas params from
2006 AscNullsLast
2021 AscNullsLast
2007− :: Expression grp commons schemas params from ('Null ty)
2022+ :: Expression outer grp commons schemas params from ('Null ty)
2008− -> SortExpression grp commons schemas params from
2023+ -> SortExpression outer grp commons schemas params from
2009 DescNullsFirst
2024 DescNullsFirst
2010− :: Expression grp commons schemas params from ('Null ty)
2025+ :: Expression outer grp commons schemas params from ('Null ty)
2011− -> SortExpression grp commons schemas params from
2026+ -> SortExpression outer grp commons schemas params from
2012 DescNullsLast
2027 DescNullsLast
2013− :: Expression grp commons schemas params from ('Null ty)
2028+ :: Expression outer grp commons schemas params from ('Null ty)
2014− -> SortExpression grp commons schemas params from
2029+ -> SortExpression outer grp commons schemas params from
2015−deriving instance Show (SortExpression grp commons schemas params from)
2030+deriving instance Show (SortExpression outer grp commons schemas params from)
2017class OrderBy expr where
2032class OrderBy expr where
2019− :: [SortExpression grp commons schemas params from]
2034+ :: [SortExpression outer grp commons schemas params from]
2020− -> expr grp commons schemas params from
2035+ -> expr outer grp commons schemas params from
2021− -> expr grp commons schemas params from
2036+ -> expr outer grp commons schemas params from
2023-- | Render a `SortExpression`.
2038-- | Render a `SortExpression`.
2024−instance RenderSQL (SortExpression grp commons schemas params from) where
2039+instance RenderSQL (SortExpression outer grp commons schemas params from) where
2025 renderSQL = \case
2040 renderSQL = \case
2026 Asc expression -> renderSQL expression <+> "ASC"
2041 Asc expression -> renderSQL expression <+> "ASC"
2027 Desc expression -> renderSQL expression <+> "DESC"
2042 Desc expression -> renderSQL expression <+> "DESC"
@@ -2032,18 +2047,18 @@ instance RenderSQL (SortExpression grp commons schemas params from) where
2032 AscNullsLast expression -> renderSQL expression <+> "ASC NULLS LAST"
2047 AscNullsLast expression -> renderSQL expression <+> "ASC NULLS LAST"
2033 DescNullsLast expression -> renderSQL expression <+> "DESC NULLS LAST"
2048 DescNullsLast expression -> renderSQL expression <+> "DESC NULLS LAST"
2035−data WindowDefinition grp commons schemas params from where
2050+data WindowDefinition outer grp commons schemas params from where
2036 WindowDefinition
2051 WindowDefinition
2037 :: SListI bys
2052 :: SListI bys
2038− => NP (Expression grp commons schemas params from) bys
2053+ => NP (Expression outer grp commons schemas params from) bys
2039− -> [SortExpression grp commons schemas params from]
2054+ -> [SortExpression outer grp commons schemas params from]
2040− -> WindowDefinition grp commons schemas params from
2055+ -> WindowDefinition outer grp commons schemas params from
2042instance OrderBy WindowDefinition where
2057instance OrderBy WindowDefinition where
2043 orderBy sortsR (WindowDefinition parts sortsL)
2058 orderBy sortsR (WindowDefinition parts sortsL)
2044 = WindowDefinition parts (sortsL ++ sortsR)
2059 = WindowDefinition parts (sortsL ++ sortsR)
2046−instance RenderSQL (WindowDefinition commons schemas from grp params) where
2061+instance RenderSQL (WindowDefinition outer commons schemas from grp params) where
2047 renderSQL (WindowDefinition part ord) =
2062 renderSQL (WindowDefinition part ord) =
2048 renderPartitionByClause part <> renderOrderByClause ord
2063 renderPartitionByClause part <> renderOrderByClause ord
@@ -2057,11 +2072,12 @@ instance RenderSQL (WindowDefinition commons schemas from grp params) where
2058partitionBy
2073partitionBy
2059 :: SListI bys
2074 :: SListI bys
2060− => NP (Expression grp commons schemas params from) bys
2075+ => NP (Expression outer grp commons schemas params from) bys
2061− -> WindowDefinition grp commons schemas params from
2076+ -> WindowDefinition outer grp commons schemas params from
2062partitionBy bys = WindowDefinition bys []
2077partitionBy bys = WindowDefinition bys []
2064newtype WindowFunction
2079newtype WindowFunction
2080+ (outer :: FromType)
2065 (grp :: Grouping)
2081 (grp :: Grouping)
2066 (commons :: FromType)
2082 (commons :: FromType)
2067 (schemas :: SchemasType)
2083 (schemas :: SchemasType)
@@ -2071,20 +2087,20 @@ newtype WindowFunction
2071 = UnsafeWindowFunction { renderWindowFunction :: ByteString }
2087 = UnsafeWindowFunction { renderWindowFunction :: ByteString }
2072 deriving (GHC.Generic,Show,Eq,Ord,NFData)
2088 deriving (GHC.Generic,Show,Eq,Ord,NFData)
2074−instance RenderSQL (WindowFunction grp commons schemas params from ty) where
2090+instance RenderSQL (WindowFunction outer grp commons schemas params from ty) where
2075 renderSQL = renderWindowFunction
2091 renderSQL = renderWindowFunction
2077unsafeWindowFunction1
2093unsafeWindowFunction1
2078 :: ByteString
2094 :: ByteString
2079− -> Expression grp commons schemas params from ty0
2095+ -> Expression outer grp commons schemas params from ty0
2080− -> WindowFunction grp commons schemas params from ty1
2096+ -> WindowFunction outer grp commons schemas params from ty1
2081unsafeWindowFunction1 fun x
2097unsafeWindowFunction1 fun x
2082 = UnsafeWindowFunction $ fun <> parenthesized (renderSQL x)
2098 = UnsafeWindowFunction $ fun <> parenthesized (renderSQL x)
2084unsafeWindowFunction2
2100unsafeWindowFunction2
2085 :: ByteString
2101 :: ByteString
2086− -> (Expression grp commons schemas params from :*: Expression grp commons schemas params from) ty0
2102+ -> (Expression outer grp commons schemas params from :*: Expression outer grp commons schemas params from) ty0
2087− -> WindowFunction grp commons schemas params from ty1
2103+ -> WindowFunction outer grp commons schemas params from ty1
2088unsafeWindowFunction2 fun (x :*: x')
2104unsafeWindowFunction2 fun (x :*: x')
2089 = UnsafeWindowFunction $ fun <> parenthesized (renderSQL x <> ", " <> renderSQL x')
2105 = UnsafeWindowFunction $ fun <> parenthesized (renderSQL x <> ", " <> renderSQL x')
@@ -2092,28 +2108,28 @@ unsafeWindowFunction2 fun (x :*: x')
2092>>> printSQL rank
2108>>> printSQL rank
2095−rank :: WindowFunction grp commons schemas params from ('NotNull 'PGint8)
2111+rank :: WindowFunction outer grp commons schemas params from ('NotNull 'PGint8)
2096rank = UnsafeWindowFunction "rank()"
2112rank = UnsafeWindowFunction "rank()"
2098{- | number of the current row within its partition, counting from 1
2114{- | number of the current row within its partition, counting from 1
2099>>> printSQL rowNumber
2115>>> printSQL rowNumber
2100row_number()
2116row_number()
2102−rowNumber :: WindowFunction grp commons schemas params from ('NotNull 'PGint8)
2118+rowNumber :: WindowFunction outer grp commons schemas params from ('NotNull 'PGint8)
2103rowNumber = UnsafeWindowFunction "row_number()"
2119rowNumber = UnsafeWindowFunction "row_number()"
2105{- | rank of the current row without gaps; this function counts peer groups
2121{- | rank of the current row without gaps; this function counts peer groups
2106>>> printSQL denseRank
2122>>> printSQL denseRank
2107dense_rank()
2123dense_rank()
2109−denseRank :: WindowFunction grp commons schemas params from ('NotNull 'PGint8)
2125+denseRank :: WindowFunction outer grp commons schemas params from ('NotNull 'PGint8)
2110denseRank = UnsafeWindowFunction "dense_rank()"
2126denseRank = UnsafeWindowFunction "dense_rank()"
2112{- | relative rank of the current row: (rank - 1) / (total partition rows - 1)
2128{- | relative rank of the current row: (rank - 1) / (total partition rows - 1)
2113>>> printSQL percentRank
2129>>> printSQL percentRank
2114percent_rank()
2130percent_rank()
2116−percentRank :: WindowFunction grp commons schemas params from ('NotNull 'PGfloat8)
2132+percentRank :: WindowFunction outer grp commons schemas params from ('NotNull 'PGfloat8)
2117percentRank = UnsafeWindowFunction "percent_rank()"
2133percentRank = UnsafeWindowFunction "percent_rank()"
2119{- | cumulative distribution: (number of partition rows
2135{- | cumulative distribution: (number of partition rows
@@ -2121,16 +2137,16 @@ preceding or peer with current row) / total partition rows
2121>>> printSQL cumeDist
2137>>> printSQL cumeDist
2122cume_dist()
2138cume_dist()
2124−cumeDist :: WindowFunction grp commons schemas params from ('NotNull 'PGfloat8)
2140+cumeDist :: WindowFunction outer grp commons schemas params from ('NotNull 'PGfloat8)
2125cumeDist = UnsafeWindowFunction "cume_dist()"
2141cumeDist = UnsafeWindowFunction "cume_dist()"
2127{- | integer ranging from 1 to the argument value,
2143{- | integer ranging from 1 to the argument value,
2128dividing the partition as equally as possible
2144dividing the partition as equally as possible
2131− :: Expression grp commons schemas params from ('NotNull 'PGint4)
2147+ :: Expression outer grp commons schemas params from ('NotNull 'PGint4)
2132 -- ^ num buckets
2148 -- ^ num buckets
2133− -> WindowFunction grp commons schemas params from ('NotNull 'PGint4)
2149+ -> WindowFunction outer grp commons schemas params from ('NotNull 'PGint4)
2134ntile = unsafeWindowFunction1 "ntile"
2150ntile = unsafeWindowFunction1 "ntile"
2136{- | returns value evaluated at the row that is offset rows before the current
2152{- | returns value evaluated at the row that is offset rows before the current
@@ -2139,13 +2155,13 @@ row within the partition; if there is no such row, instead return default
2139evaluated with respect to the current row.
2155evaluated with respect to the current row.
2142− :: Expression grp commons schemas params from ty
2158+ :: Expression outer grp commons schemas params from ty
2143 -- ^ value
2159 -- ^ value
2144− -> Expression grp commons schemas params from ('NotNull 'PGint4)
2160+ -> Expression outer grp commons schemas params from ('NotNull 'PGint4)
2145 -- ^ offset
2161 -- ^ offset
2146− -> Expression grp commons schemas params from ty
2162+ -> Expression outer grp commons schemas params from ty
2147 -- ^ default
2163 -- ^ default
2148− -> WindowFunction grp commons schemas params from ty
2164+ -> WindowFunction outer grp commons schemas params from ty
2149lag value offset def = UnsafeWindowFunction $ "lag"
2165lag value offset def = UnsafeWindowFunction $ "lag"
2150 <> parenthesized
2166 <> parenthesized
2151 (commaSeparated ([renderSQL value, renderSQL offset, renderSQL def]))
2167 (commaSeparated ([renderSQL value, renderSQL offset, renderSQL def]))
@@ -2156,13 +2172,13 @@ row within the partition; if there is no such row, instead return default
2156evaluated with respect to the current row.
2172evaluated with respect to the current row.
2159− :: Expression grp commons schemas params from ty
2175+ :: Expression outer grp commons schemas params from ty
2160 -- ^ value
2176 -- ^ value
2161− -> Expression grp commons schemas params from ('NotNull 'PGint4)
2177+ -> Expression outer grp commons schemas params from ('NotNull 'PGint4)
2162 -- ^ offset
2178 -- ^ offset
2163− -> Expression grp commons schemas params from ty
2179+ -> Expression outer grp commons schemas params from ty
2164 -- ^ default
2180 -- ^ default
2165− -> WindowFunction grp commons schemas params from ty
2181+ -> WindowFunction outer grp commons schemas params from ty
2166lead value offset def = UnsafeWindowFunction $ "lag"
2182lead value offset def = UnsafeWindowFunction $ "lag"
2167 <> parenthesized
2183 <> parenthesized
2168 (commaSeparated ([renderSQL value, renderSQL offset, renderSQL def]))
2184 (commaSeparated ([renderSQL value, renderSQL offset, renderSQL def]))
@@ -2171,28 +2187,28 @@ lead value offset def = UnsafeWindowFunction $ "lag"
2171first row of the window frame
2187first row of the window frame
2173firstValue
2189firstValue
2174− :: Expression grp commons schemas params from ty
2190+ :: Expression outer grp commons schemas params from ty
2175 -- ^ value
2191 -- ^ value
2176− -> WindowFunction grp commons schemas params from ty
2192+ -> WindowFunction outer grp commons schemas params from ty
2177firstValue = unsafeWindowFunction1 "first_value"
2193firstValue = unsafeWindowFunction1 "first_value"
2179{- | returns value evaluated at the row that is the
2195{- | returns value evaluated at the row that is the
2180last row of the window frame
2196last row of the window frame
2182lastValue
2198lastValue
2183− :: Expression grp commons schemas params from ty
2199+ :: Expression outer grp commons schemas params from ty
2184 -- ^ value
2200 -- ^ value
2185− -> WindowFunction grp commons schemas params from ty
2201+ -> WindowFunction outer grp commons schemas params from ty
2186lastValue = unsafeWindowFunction1 "last_value"
2202lastValue = unsafeWindowFunction1 "last_value"
2188{- | returns value evaluated at the row that is the nth
2204{- | returns value evaluated at the row that is the nth
2189row of the window frame (counting from 1); null if no such row
2205row of the window frame (counting from 1); null if no such row
2192− :: Expression grp commons schemas params from (nullity ty)
2208+ :: Expression outer grp commons schemas params from (nullity ty)
2193 -- ^ value
2209 -- ^ value
2194− -> Expression grp commons schemas params from ('NotNull 'PGint4)
2210+ -> Expression outer grp commons schemas params from ('NotNull 'PGint4)
2195 -- ^ nth
2211 -- ^ nth
2196− -> WindowFunction grp commons schemas params from ('Null ty)
2212+ -> WindowFunction outer grp commons schemas params from ('Null ty)
2197nthValue value nth = UnsafeWindowFunction $ "nth_value"
2213nthValue value nth = UnsafeWindowFunction $ "nth_value"
2198 <> parenthesized (commaSeparated [renderSQL value, renderSQL nth])
2214 <> parenthesized (commaSeparated [renderSQL value, renderSQL nth])