git.iko.soy/squeal
on dev help sign in
Merge pull request #102 from morphismtech/dev-subquery2

Subqueries

commita046471f4650b3ebc29d2dc24a30574d3978338c authorEitan Chatav <eitan.chatav@gmail.com> dateWed 20 Feb 2019, 20:22 (8 years ago) parent0a95a9d53f1afa
7 files changed+699−855
compare with dev
unifiedsplit
squeal-postgresql/exe/Example.hs+4−8 squeal-postgresql/src/Squeal/PostgreSQL/Definition.hs+4−4 squeal-postgresql/src/Squeal/PostgreSQL/Expression.hs+379−363 squeal-postgresql/src/Squeal/PostgreSQL/Manipulation.hs+19−18 squeal-postgresql/src/Squeal/PostgreSQL/Migration.hs+1−1 squeal-postgresql/src/Squeal/PostgreSQL/PQ.hs+2−2 squeal-postgresql/src/Squeal/PostgreSQL/Query.hs+290−459
squeal-postgresql/exe/Example.hs+4−8
@@ -44,7 +44,7 @@ type Schema =
4444type Schemas = Public Schema
4545
4646setup :: Definition (Public '[]) Schemas
47−setup =
47+setup =
4848 createTable #users
4949 ( serial `as` #id :*
5050 (text & notNullable) `as` #name :*
@@ -62,20 +62,16 @@ setup =
6262teardown :: Definition Schemas (Public '[])
6363teardown = dropTable #emails >>> dropTable #users
6464
65−insertUser :: Manipulation '[] Schemas '[ 'NotNull 'PGtext, 'NotNull ('PGvararray ('Null 'PGint2))]
66− '[ "fromOnly" ::: 'NotNull 'PGint4 ]
65+insertUser :: Manipulation_ Schemas (Text, VarArray (Vector (Maybe Int16))) (Only Int32)
6766insertUser = insertInto #users
6867 (Values_ (defaultAs #id :* param @1 `as` #name :* param @2 `as` #vec))
6968 (OnConflict (OnConstraint #pk_users) DoNothing) (Returning_ (#id `as` #fromOnly))
7069
71−insertEmail :: Manipulation '[] Schemas '[ 'NotNull 'PGint4, 'Null 'PGtext] '[]
70+insertEmail :: Manipulation_ Schemas (Int32, Maybe Text) ()
7271insertEmail = insertInto_ #emails
7372 (Values_ (defaultAs #id :* param @1 `as` #user_id :* param @2 `as` #email))
7473
75−getUsers :: Query '[] Schemas '[]
76− '[ "userName" ::: 'NotNull 'PGtext
77− , "userEmail" ::: 'Null 'PGtext
78− , "userVec" ::: 'NotNull ('PGvararray ('Null 'PGint2))]
74+getUsers :: Query_ Schemas () User
7975getUsers = select_
8076 (#u ! #name `as` #userName :* #e ! #email `as` #userEmail :* #u ! #vec `as` #userVec)
8177 ( from (table (#users `as` #u)
squeal-postgresql/src/Squeal/PostgreSQL/Definition.hs+4−4
@@ -297,7 +297,7 @@ check
297297 , HasAll aliases (TableToRow table) subcolumns )
298298 => NP Alias aliases
299299 -- ^ specify the subcolumns which are getting checked
300− -> (forall t. Condition 'Ungrouped '[] schemas '[] '[t ::: subcolumns])
300+ -> (forall t. Condition '[] 'Ungrouped '[] schemas '[] '[t ::: subcolumns])
301301 -- ^ a closed `Condition` on those subcolumns
302302 -> TableConstraintExpression sch tab schemas ('Check aliases)
303303check _cols condition = UnsafeTableConstraintExpression $
@@ -772,7 +772,7 @@ newtype AlterColumn (schemas :: SchemasType) (ty0 :: ColumnType) (ty1 :: ColumnT
772772-- :}
773773-- ALTER TABLE "tab" ALTER COLUMN "col" SET DEFAULT 5;
774774setDefault
775− :: Expression 'Ungrouped '[] schemas '[] '[] ty -- ^ default value to set
775+ :: Expression '[] 'Ungrouped '[] schemas '[] '[] ty -- ^ default value to set
776776 -> AlterColumn schemas (constraint :=> ty) ('Def :=> ty)
777777setDefault expression = UnsafeAlterColumn $
778778 "SET DEFAULT" <+> renderExpression expression
@@ -857,7 +857,7 @@ CREATE VIEW "bc" AS SELECT "b" AS "b", "c" AS "c" FROM "abc" AS "abc";
857857createView
858858 :: (KnownSymbol sch, KnownSymbol vw, Has sch schemas schema)
859859 => QualifiedAlias sch vw -- ^ the name of the view to add
860− -> Query '[] schemas '[] view -- ^ query
860+ -> Query '[] '[] schemas '[] view -- ^ query
861861 -> Definition schemas (Alter sch (Create vw ('View view) schema) schemas)
862862createView alias query = UnsafeDefinition $
863863 "CREATE" <+> "VIEW" <+> renderSQL alias <+> "AS"
@@ -1023,7 +1023,7 @@ notNullable ty = UnsafeColumnTypeExpression $ renderSQL ty <+> "NOT NULL"
10231023
10241024-- | used in `createTable` commands as a column constraint to give a default
10251025default_
1026− :: Expression 'Ungrouped '[] schemas '[] '[] ty
1026+ :: Expression '[] 'Ungrouped '[] schemas '[] '[] ty
10271027 -> ColumnTypeExpression schemas ('NoDef :=> ty)
10281028 -> ColumnTypeExpression schemas ('Def :=> ty)
10291029default_ x ty = UnsafeColumnTypeExpression $
squeal-postgresql/src/Squeal/PostgreSQL/Expression.hs+379−363
@@ -237,6 +237,7 @@ values from primitive expression using arithmetic, logical,
237237and other operations.
238238-}
239239newtype Expression
240+ (outer :: FromType)
240241 (grp :: Grouping)
241242 (commons :: FromType)
242243 (schemas :: SchemasType)
@@ -246,7 +247,7 @@ newtype Expression
246247 = UnsafeExpression { renderExpression :: ByteString }
247248 deriving (GHC.Generic,Show,Eq,Ord,NFData)
248249
249−instance RenderSQL (Expression grp commons schemas params from ty) where
250+instance RenderSQL (Expression outer grp commons schemas params from ty) where
250251 renderSQL = renderExpression
251252
252253{- | A `HasParameter` constraint is used to indicate a value that is
@@ -264,12 +265,12 @@ class KnownNat n => HasParameter
264265 | n params -> ty where
265266 -- | `parameter` takes a `Nat` using type application and a `TypeExpression`.
266267 --
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)
268269 -- >>> printSQL expr
269270 -- ($1 :: int4)
270271 parameter
271272 :: TypeExpression schemas ty
272− -> Expression grp commons schemas params from ty
273+ -> Expression outer grp commons schemas params from ty
273274 parameter ty = UnsafeExpression $ parenthesized $
274275 "$" <> renderNat @n <+> "::"
275276 <+> renderSQL ty
@@ -280,116 +281,116 @@ instance {-# OVERLAPPABLE #-} (KnownNat n, HasParameter (n-1) params ty)
280281-- | `param` takes a `Nat` using type application and for basic types,
281282-- infers a `TypeExpression`.
282283--
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)
284285-- >>> printSQL expr
285286-- ($1 :: int4)
286287param
287− :: forall n commons schemas params from grp ty
288+ :: forall n outer commons schemas params from grp ty
288289 . (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
290291param = parameter @n (pgtype @schemas)
291292
292−instance (HasUnique tab from row, Has col row ty)
293− => IsLabel col (Expression 'Ungrouped commons schemas params from ty) where
293+instance (HasUnique tab (Join outer from) row, Has col row ty)
294+ => IsLabel col (Expression outer 'Ungrouped commons schemas params from ty) where
294295 fromLabel = UnsafeExpression $ renderSQL (Alias @col)
295−instance (HasUnique tab from row, Has col row ty, tys ~ '[ty])
296− => IsLabel col (NP (Expression 'Ungrouped commons schemas params from) tys) where
296+instance (HasUnique tab (Join outer from) row, Has col row ty, tys ~ '[ty])
297+ => IsLabel col (NP (Expression outer 'Ungrouped commons schemas params from) tys) where
297298 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))
299300 => IsLabel col
300− (Aliased (Expression 'Ungrouped commons schemas params from) column) where
301+ (Aliased (Expression outer 'Ungrouped commons schemas params from) column) where
301302 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])
303304 => 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
305306 fromLabel = fromLabel @col :* Nil
306307
307−instance (Has tab from row, Has col row ty)
308− => IsQualified tab col (Expression 'Ungrouped commons schemas params from ty) where
308+instance (Has tab (Join outer from) row, Has col row ty)
309+ => IsQualified tab col (Expression outer 'Ungrouped commons schemas params from ty) where
309310 tab ! col = UnsafeExpression $
310311 renderSQL tab <> "." <> renderSQL col
311−instance (Has tab from row, Has col row ty, tys ~ '[ty])
312− => IsQualified tab col (NP (Expression 'Ungrouped commons schemas params from) tys) where
312+instance (Has tab (Join outer from) row, Has col row ty, tys ~ '[ty])
313+ => IsQualified tab col (NP (Expression outer 'Ungrouped commons schemas params from) tys) where
313314 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))
315316 => IsQualified tab col
316− (Aliased (Expression 'Ungrouped commons schemas params from) column) where
317+ (Aliased (Expression outer 'Ungrouped commons schemas params from) column) where
317318 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])
319320 => 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
321322 tab ! col = tab ! col :* Nil
322323
323324instance
324− ( HasUnique tab from row
325+ ( HasUnique tab (Join outer from) row
325326 , Has col row ty
326327 , GroupedBy tab col bys
327328 ) => IsLabel col
328− (Expression ('Grouped bys) commons schemas params from ty) where
329+ (Expression outer ('Grouped bys) commons schemas params from ty) where
329330 fromLabel = UnsafeExpression $ renderSQL (Alias @col)
330331instance
331− ( HasUnique tab from row
332+ ( HasUnique tab (Join outer from) row
332333 , Has col row ty
333334 , GroupedBy tab col bys
334335 , tys ~ '[ty]
335336 ) => 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
337338 fromLabel = fromLabel @col :* Nil
338339instance
339− ( HasUnique tab from row
340+ ( HasUnique tab (Join outer from) row
340341 , Has col row ty
341342 , GroupedBy tab col bys
342343 , column ~ (col ::: ty)
343344 ) => 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
345346 fromLabel = fromLabel @col `As` Alias
346347instance
347− ( HasUnique tab from row
348+ ( HasUnique tab (Join outer from) row
348349 , Has col row ty
349350 , GroupedBy tab col bys
350351 , columns ~ '[col ::: ty]
351352 ) => 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
353354 fromLabel = fromLabel @col :* Nil
354355
355356instance
356− ( Has tab from row
357+ ( Has tab (Join outer from) row
357358 , Has col row ty
358359 , GroupedBy tab col bys
359360 ) => IsQualified tab col
360− (Expression ('Grouped bys) commons schemas params from ty) where
361+ (Expression outer ('Grouped bys) commons schemas params from ty) where
361362 tab ! col = UnsafeExpression $
362363 renderSQL tab <> "." <> renderSQL col
363364instance
364− ( Has tab from row
365+ ( Has tab (Join outer from) row
365366 , Has col row ty
366367 , GroupedBy tab col bys
367368 , tys ~ '[ty]
368369 ) => 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
370371 tab ! col = tab ! col :* Nil
371372instance
372− ( Has tab from row
373+ ( Has tab (Join outer from) row
373374 , Has col row ty
374375 , GroupedBy tab col bys
375376 , column ~ (col ::: ty)
376377 ) => 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
378379 tab ! col = tab ! col `As` col
379380instance
380− ( Has tab from row
381+ ( Has tab (Join outer from) row
381382 , Has col row ty
382383 , GroupedBy tab col bys
383384 , columns ~ '[col ::: ty]
384385 ) => 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
386387 tab ! col = tab ! col :* Nil
387388
388389-- | analagous to `Nothing`
389390--
390391-- >>> printSQL null_
391392-- NULL
392−null_ :: Expression commons schemas rels grouping params ('Null ty)
393+null_ :: Expression outer grp commons schemas params from ('Null ty)
393394null_ = UnsafeExpression "NULL"
394395
395396-- | analagous to `Just`
@@ -397,8 +398,8 @@ null_ = UnsafeExpression "NULL"
397398-- >>> printSQL $ notNull true
398399-- TRUE
399400notNull
400− :: Expression commons schemas rels grouping params ('NotNull ty)
401− -> Expression commons schemas rels grouping params ('Null ty)
401+ :: Expression outer grp commons schemas params from ('NotNull ty)
402+ -> Expression outer grp commons schemas params from ('Null ty)
402403notNull = UnsafeExpression . renderSQL
403404
404405-- | return the leftmost value which is not NULL
@@ -406,11 +407,11 @@ notNull = UnsafeExpression . renderSQL
406407-- >>> printSQL $ coalesce [null_, true] false
407408-- COALESCE(NULL, TRUE, FALSE)
408409coalesce
409− :: [Expression grp commons schemas params from ('Null ty)]
410+ :: [Expression outer grp commons schemas params from ('Null ty)]
410411 -- ^ @NULL@s may be present
411− -> Expression grp commons schemas params from ('NotNull ty)
412+ -> Expression outer grp commons schemas params from ('NotNull ty)
412413 -- ^ @NULL@ is absent
413− -> Expression grp commons schemas params from ('NotNull ty)
414+ -> Expression outer grp commons schemas params from ('NotNull ty)
414415coalesce nullxs notNullx = UnsafeExpression $
415416 "COALESCE" <> parenthesized (commaSeparated
416417 ((renderSQL <$> nullxs) <> [renderSQL notNullx]))
@@ -420,26 +421,26 @@ coalesce nullxs notNullx = UnsafeExpression $
420421-- >>> printSQL $ fromNull true null_
421422-- COALESCE(NULL, TRUE)
422423fromNull
423− :: Expression grp commons schemas params from ('NotNull ty)
424+ :: Expression outer grp commons schemas params from ('NotNull ty)
424425 -- ^ what to convert @NULL@ to
425− -> Expression grp commons schemas params from ('Null ty)
426− -> Expression grp commons schemas params from ('NotNull ty)
426+ -> Expression outer grp commons schemas params from ('Null ty)
427+ -> Expression outer grp commons schemas params from ('NotNull ty)
427428fromNull notNullx nullx = coalesce [nullx] notNullx
428429
429430-- | >>> printSQL $ null_ & isNull
430431-- NULL IS NULL
431432isNull
432− :: Expression grp commons schemas params from ('Null ty)
433+ :: Expression outer grp commons schemas params from ('Null ty)
433434 -- ^ possibly @NULL@
434− -> Condition grp commons schemas params from
435+ -> Condition outer grp commons schemas params from
435436isNull x = UnsafeExpression $ renderSQL x <+> "IS NULL"
436437
437438-- | >>> printSQL $ null_ & isNotNull
438439-- NULL IS NOT NULL
439440isNotNull
440− :: Expression grp commons schemas params from ('Null ty)
441+ :: Expression outer grp commons schemas params from ('Null ty)
441442 -- ^ possibly @NULL@
442− -> Condition grp commons schemas params from
443+ -> Condition outer grp commons schemas params from
443444isNotNull x = UnsafeExpression $ renderSQL x <+> "IS NOT NULL"
444445
445446-- | analagous to `maybe` using @IS NULL@
@@ -447,13 +448,13 @@ isNotNull x = UnsafeExpression $ renderSQL x <+> "IS NOT NULL"
447448-- >>> printSQL $ matchNull true not_ null_
448449-- CASE WHEN NULL IS NULL THEN TRUE ELSE (NOT NULL) END
449450matchNull
450− :: Expression grp commons schemas params from (nullty)
451+ :: Expression outer grp commons schemas params from (nullty)
451452 -- ^ what to convert @NULL@ to
452− -> ( Expression grp commons schemas params from ('NotNull ty)
453− -> Expression grp commons schemas params from (nullty) )
453+ -> ( Expression outer grp commons schemas params from ('NotNull ty)
454+ -> Expression outer grp commons schemas params from (nullty) )
454455 -- ^ function to perform when @NULL@ is absent
455− -> Expression grp commons schemas params from ('Null ty)
456− -> Expression grp commons schemas params from (nullty)
456+ -> Expression outer grp commons schemas params from ('Null ty)
457+ -> Expression outer grp commons schemas params from (nullty)
457458matchNull y f x = ifThenElse (isNull x) y
458459 (f (UnsafeExpression (renderSQL x)))
459460
@@ -461,25 +462,25 @@ matchNull y f x = ifThenElse (isNull x) y
461462`nullIf` gives @NULL@.
462463
463464>>> :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)
465466>>> printSQL expr
466467NULL IF (FALSE, ($1 :: bool))
467468-}
468469nullIf
469− :: Expression grp commons schemas params from ('NotNull ty)
470+ :: Expression outer grp commons schemas params from ('NotNull ty)
470471 -- ^ @NULL@ is absent
471− -> Expression grp commons schemas params from ('NotNull ty)
472+ -> Expression outer grp commons schemas params from ('NotNull ty)
472473 -- ^ @NULL@ is absent
473− -> Expression grp commons schemas params from ('Null ty)
474+ -> Expression outer grp commons schemas params from ('Null ty)
474475nullIf x y = UnsafeExpression $ "NULL IF" <+> parenthesized
475476 (renderSQL x <> ", " <> renderSQL y)
476477
477478-- | >>> printSQL $ array [null_, false, true]
478479-- ARRAY[NULL, FALSE, TRUE]
479480array
480− :: [Expression grp commons schemas params from ty]
481+ :: [Expression outer grp commons schemas params from ty]
481482 -- ^ array elements
482− -> Expression grp commons schemas params from (nullity ('PGvararray ty))
483+ -> Expression outer grp commons schemas params from (nullity ('PGvararray ty))
483484array xs = UnsafeExpression $
484485 "ARRAY[" <> commaSeparated (renderSQL <$> xs) <> "]"
485486
@@ -487,13 +488,13 @@ array xs = UnsafeExpression $
487488-- (ARRAY[NULL, FALSE, TRUE])[2]
488489index
489490 :: Word64 -- ^ index
490− -> Expression grp commons schemas params from (nullity ('PGvararray ty)) -- ^ array
491− -> Expression grp commons schemas params from (NullifyType ty)
491+ -> Expression outer grp commons schemas params from (nullity ('PGvararray ty)) -- ^ array
492+ -> Expression outer grp commons schemas params from (NullifyType ty)
492493index n expr = UnsafeExpression $
493494 parenthesized (renderSQL expr) <> "[" <> fromString (show n) <> "]"
494495
495496instance (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
497498 label = UnsafeExpression $ renderSQL (PGlabel @label)
498499
499500-- | A row constructor is an expression that builds a row value
@@ -505,14 +506,14 @@ instance (KnownSymbol label, label `In` labels) => IsPGlabel label
505506-- , "imaginary" ::: 'NotNull 'PGfloat8 ]
506507-- :}
507508--
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)
509510-- >>> printSQL i
510511-- ROW(0, 1)
511512row
512513 :: SListI row
513− => NP (Aliased (Expression grp commons schemas params from)) row
514+ => NP (Aliased (Expression outer grp commons schemas params from)) row
514515 -- ^ 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))
516517row exprs = UnsafeExpression $ "ROW" <> parenthesized
517518 (renderCommaSeparated (\ (expr `As` _) -> renderSQL expr) exprs)
518519
@@ -523,7 +524,7 @@ row exprs = UnsafeExpression $ "ROW" <> parenthesized
523524-- type Schema = '["complex" ::: 'Typedef Complex]
524525-- :}
525526--
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)
527528-- >>> printSQL $ i & field #complex #imaginary
528529-- (ROW(0, 1)::"complex")."imaginary"
529530field
@@ -532,41 +533,41 @@ field
532533 , Has field row ty)
533534 => QualifiedAlias sch tydef -- ^ row type
534535 -> Alias field -- ^ field name
535− -> Expression grp commons schemas params from ('NotNull ('PGcomposite row))
536− -> Expression grp commons schemas params from ty
536+ -> Expression outer grp commons schemas params from ('NotNull ('PGcomposite row))
537+ -> Expression outer grp commons schemas params from ty
537538field td fld expr = UnsafeExpression $
538539 parenthesized (renderSQL expr <> "::" <> renderSQL td)
539540 <> "." <> renderSQL fld
540541
541542instance Semigroup
542− (Expression grp commons schemas params from (nullity ('PGvararray ty))) where
543+ (Expression outer grp commons schemas params from (nullity ('PGvararray ty))) where
543544 (<>) = unsafeBinaryOp "||"
544545
545546instance Monoid
546− (Expression grp commons schemas params from (nullity ('PGvararray ty))) where
547+ (Expression outer grp commons schemas params from (nullity ('PGvararray ty))) where
547548 mempty = array []
548549 mappend = (<>)
549550
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)
551552-- >>> printSQL expr
552553-- GREATEST(CURRENT_TIMESTAMP, ($1 :: timestamp with time zone))
553554greatest
554− :: Expression grp commons schemas params from (nullty)
555+ :: Expression outer grp commons schemas params from (nullty)
555556 -- ^ needs at least 1 argument
556− -> [Expression grp commons schemas params from (nullty)]
557+ -> [Expression outer grp commons schemas params from (nullty)]
557558 -- ^ or more
558− -> Expression grp commons schemas params from (nullty)
559+ -> Expression outer grp commons schemas params from (nullty)
559560greatest x xs = UnsafeExpression $ "GREATEST("
560561 <> commaSeparated (renderSQL <$> (x:xs)) <> ")"
561562
562563-- | >>> printSQL $ least currentTimestamp [null_]
563564-- LEAST(CURRENT_TIMESTAMP, NULL)
564565least
565− :: Expression grp commons schemas params from (nullty)
566+ :: Expression outer grp commons schemas params from (nullty)
566567 -- ^ needs at least 1 argument
567− -> [Expression grp commons schemas params from (nullty)]
568+ -> [Expression outer grp commons schemas params from (nullty)]
568569 -- ^ or more
569− -> Expression grp commons schemas params from (nullty)
570+ -> Expression outer grp commons schemas params from (nullty)
570571least x xs = UnsafeExpression $ "LEAST("
571572 <> commaSeparated (renderSQL <$> (x:xs)) <> ")"
572573
@@ -575,9 +576,9 @@ least x xs = UnsafeExpression $ "LEAST("
575576unsafeBinaryOp
576577 :: ByteString
577578 -- ^ operator
578− -> Expression grp commons schemas params from (ty0)
579− -> Expression grp commons schemas params from (ty1)
580− -> Expression grp commons schemas params from (ty2)
579+ -> Expression outer grp commons schemas params from (ty0)
580+ -> Expression outer grp commons schemas params from (ty1)
581+ -> Expression outer grp commons schemas params from (ty2)
581582unsafeBinaryOp op x y = UnsafeExpression $ parenthesized $
582583 renderSQL x <+> op <+> renderSQL y
583584
@@ -586,8 +587,8 @@ unsafeBinaryOp op x y = UnsafeExpression $ parenthesized $
586587unsafeUnaryOp
587588 :: ByteString
588589 -- ^ operator
589− -> Expression grp commons schemas params from (ty0)
590− -> Expression grp commons schemas params from (ty1)
590+ -> Expression outer grp commons schemas params from (ty0)
591+ -> Expression outer grp commons schemas params from (ty1)
591592unsafeUnaryOp op x = UnsafeExpression $ parenthesized $
592593 op <+> renderSQL x
593594
@@ -596,8 +597,8 @@ unsafeUnaryOp op x = UnsafeExpression $ parenthesized $
596597unsafeFunction
597598 :: ByteString
598599 -- ^ function
599− -> Expression grp commons schemas params from (xty)
600− -> Expression grp commons schemas params from (yty)
600+ -> Expression outer grp commons schemas params from (xty)
601+ -> Expression outer grp commons schemas params from (yty)
601602unsafeFunction fun x = UnsafeExpression $
602603 fun <> parenthesized (renderSQL x)
603604
@@ -606,13 +607,13 @@ unsafeVariadicFunction
606607 :: SListI elems
607608 => ByteString
608609 -- ^ function
609− -> NP (Expression grp commons schemas params from) elems
610− -> Expression grp commons schemas params from ret
610+ -> NP (Expression outer grp commons schemas params from) elems
611+ -> Expression outer grp commons schemas params from ret
611612unsafeVariadicFunction fun x = UnsafeExpression $
612613 fun <> parenthesized (commaSeparated (hcollapse (hmap (K . renderSQL) x)))
613614
614615instance 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
616617 (+) = unsafeBinaryOp "+"
617618 (-) = unsafeBinaryOp "-"
618619 (*) = unsafeBinaryOp "*"
@@ -624,12 +625,12 @@ instance ty `In` PGNum
624625 . show
625626
626627instance (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
628629 (/) = unsafeBinaryOp "/"
629630 fromRational x = fromInteger (numerator x) / fromInteger (denominator x)
630631
631632instance (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
633634 pi = UnsafeExpression "pi()"
634635 exp = unsafeFunction "exp"
635636 log = unsafeFunction "ln"
@@ -652,18 +653,18 @@ instance (ty `In` PGNum, ty `In` PGFloating) => Floating
652653
653654-- | >>> :{
654655-- let
655−-- expression :: Expression grp commons schemas params from (nullity 'PGfloat4)
656+-- expression :: Expression outer grp commons schemas params from (nullity 'PGfloat4)
656657-- expression = atan2_ pi 2
657658-- in printSQL expression
658659-- :}
659660-- atan2(pi(), 2)
660661atan2_
661662 :: float `In` PGFloating
662− => Expression grp commons schemas params from (nullity float)
663+ => Expression outer grp commons schemas params from (nullity float)
663664 -- ^ numerator
664− -> Expression grp commons schemas params from (nullity float)
665+ -> Expression outer grp commons schemas params from (nullity float)
665666 -- ^ denominator
666− -> Expression grp commons schemas params from (nullity float)
667+ -> Expression outer grp commons schemas params from (nullity float)
667668atan2_ y x = UnsafeExpression $
668669 "atan2(" <> renderSQL y <> ", " <> renderSQL x <> ")"
669670
@@ -676,9 +677,9 @@ atan2_ y x = UnsafeExpression $
676677cast
677678 :: TypeExpression schemas ty1
678679 -- ^ type to cast as
679− -> Expression grp commons schemas params from ty0
680+ -> Expression outer grp commons schemas params from ty0
680681 -- ^ value to convert
681− -> Expression grp commons schemas params from ty1
682+ -> Expression outer grp commons schemas params from ty1
682683cast ty x = UnsafeExpression $ parenthesized $
683684 renderSQL x <+> "::" <+> renderSQL ty
684685
@@ -686,136 +687,136 @@ cast ty x = UnsafeExpression $ parenthesized $
686687--
687688-- >>> :{
688689-- let
689−-- expression :: Expression grp commons schemas params from (nullity 'PGint2)
690+-- expression :: Expression outer grp commons schemas params from (nullity 'PGint2)
690691-- expression = 5 `quot_` 2
691692-- in printSQL expression
692693-- :}
693694-- (5 / 2)
694695quot_
695696 :: int `In` PGIntegral
696− => Expression grp commons schemas params from (nullity int)
697+ => Expression outer grp commons schemas params from (nullity int)
697698 -- ^ numerator
698− -> Expression grp commons schemas params from (nullity int)
699+ -> Expression outer grp commons schemas params from (nullity int)
699700 -- ^ denominator
700− -> Expression grp commons schemas params from (nullity int)
701+ -> Expression outer grp commons schemas params from (nullity int)
701702quot_ = unsafeBinaryOp "/"
702703
703704-- | remainder upon integer division
704705--
705706-- >>> :{
706707-- let
707−-- expression :: Expression grp commons schemas params from (nullity 'PGint2)
708+-- expression :: Expression outer grp commons schemas params from (nullity 'PGint2)
708709-- expression = 5 `rem_` 2
709710-- in printSQL expression
710711-- :}
711712-- (5 % 2)
712713rem_
713714 :: int `In` PGIntegral
714− => Expression grp commons schemas params from (nullity int)
715+ => Expression outer grp commons schemas params from (nullity int)
715716 -- ^ numerator
716− -> Expression grp commons schemas params from (nullity int)
717+ -> Expression outer grp commons schemas params from (nullity int)
717718 -- ^ denominator
718− -> Expression grp commons schemas params from (nullity int)
719+ -> Expression outer grp commons schemas params from (nullity int)
719720rem_ = unsafeBinaryOp "%"
720721
721722-- | >>> :{
722723-- let
723−-- expression :: Expression grp commons schemas params from (nullity 'PGfloat4)
724+-- expression :: Expression outer grp commons schemas params from (nullity 'PGfloat4)
724725-- expression = trunc pi
725726-- in printSQL expression
726727-- :}
727728-- trunc(pi())
728729trunc
729730 :: frac `In` PGFloating
730− => Expression grp commons schemas params from (nullity frac)
731+ => Expression outer grp commons schemas params from (nullity frac)
731732 -- ^ fractional number
732− -> Expression grp commons schemas params from (nullity frac)
733+ -> Expression outer grp commons schemas params from (nullity frac)
733734trunc = unsafeFunction "trunc"
734735
735736-- | >>> :{
736737-- let
737−-- expression :: Expression grp commons schemas params from (nullity 'PGfloat4)
738+-- expression :: Expression outer grp commons schemas params from (nullity 'PGfloat4)
738739-- expression = round_ pi
739740-- in printSQL expression
740741-- :}
741742-- round(pi())
742743round_
743744 :: frac `In` PGFloating
744− => Expression grp commons schemas params from (nullity frac)
745+ => Expression outer grp commons schemas params from (nullity frac)
745746 -- ^ fractional number
746− -> Expression grp commons schemas params from (nullity frac)
747+ -> Expression outer grp commons schemas params from (nullity frac)
747748round_ = unsafeFunction "round"
748749
749750-- | >>> :{
750751-- let
751−-- expression :: Expression grp commons schemas params from (nullity 'PGfloat4)
752+-- expression :: Expression outer grp commons schemas params from (nullity 'PGfloat4)
752753-- expression = ceiling_ pi
753754-- in printSQL expression
754755-- :}
755756-- ceiling(pi())
756757ceiling_
757758 :: frac `In` PGFloating
758− => Expression grp commons schemas params from (nullity frac)
759+ => Expression outer grp commons schemas params from (nullity frac)
759760 -- ^ fractional number
760− -> Expression grp commons schemas params from (nullity frac)
761+ -> Expression outer grp commons schemas params from (nullity frac)
761762ceiling_ = unsafeFunction "ceiling"
762763
763764-- | A `Condition` is an `Expression`, which can evaluate
764765-- to `true`, `false` or `null_`. This is because SQL uses
765766-- a three valued logic.
766−type Condition grp commons schemas params from =
767− Expression grp commons schemas params from ('Null 'PGbool)
767+type Condition outer grp commons schemas params from =
768+ Expression outer grp commons schemas params from ('Null 'PGbool)
768769
769770-- | >>> printSQL true
770771-- TRUE
771−true :: Expression grp commons schemas params from (nullity 'PGbool)
772+true :: Expression outer grp commons schemas params from (nullity 'PGbool)
772773true = UnsafeExpression "TRUE"
773774
774775-- | >>> printSQL false
775776-- FALSE
776−false :: Expression grp commons schemas params from (nullity 'PGbool)
777+false :: Expression outer grp commons schemas params from (nullity 'PGbool)
777778false = UnsafeExpression "FALSE"
778779
779780-- | >>> printSQL $ not_ true
780781-- (NOT TRUE)
781782not_
782− :: Expression grp commons schemas params from (nullity 'PGbool)
783− -> Expression grp commons schemas params from (nullity 'PGbool)
783+ :: Expression outer grp commons schemas params from (nullity 'PGbool)
784+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
784785not_ = unsafeUnaryOp "NOT"
785786
786787-- | >>> printSQL $ true .&& false
787788-- (TRUE AND FALSE)
788789(.&&)
789− :: Expression grp commons schemas params from (nullity 'PGbool)
790− -> Expression grp commons schemas params from (nullity 'PGbool)
791− -> Expression grp commons schemas params from (nullity 'PGbool)
790+ :: Expression outer grp commons schemas params from (nullity 'PGbool)
791+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
792+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
792793infixr 3 .&&
793794(.&&) = unsafeBinaryOp "AND"
794795
795796-- | >>> printSQL $ true .|| false
796797-- (TRUE OR FALSE)
797798(.||)
798− :: Expression grp commons schemas params from (nullity 'PGbool)
799− -> Expression grp commons schemas params from (nullity 'PGbool)
800− -> Expression grp commons schemas params from (nullity 'PGbool)
799+ :: Expression outer grp commons schemas params from (nullity 'PGbool)
800+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
801+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
801802infixr 2 .||
802803(.||) = unsafeBinaryOp "OR"
803804
804805-- | >>> :{
805806-- let
806−-- expression :: Expression grp commons schemas params from (nullity 'PGint2)
807+-- expression :: Expression outer grp commons schemas params from (nullity 'PGint2)
807808-- expression = caseWhenThenElse [(true, 1), (false, 2)] 3
808809-- in printSQL expression
809810-- :}
810811-- CASE WHEN TRUE THEN 1 WHEN FALSE THEN 2 ELSE 3 END
811812caseWhenThenElse
812− :: [ ( Condition grp commons schemas params from
813− , Expression grp commons schemas params from ty
813+ :: [ ( Condition outer grp commons schemas params from
814+ , Expression outer grp commons schemas params from ty
814815 ) ]
815816 -- ^ whens and thens
816− -> Expression grp commons schemas params from ty
817+ -> Expression outer grp commons schemas params from ty
817818 -- ^ else
818− -> Expression grp commons schemas params from ty
819+ -> Expression outer grp commons schemas params from ty
819820caseWhenThenElse whenThens else_ = UnsafeExpression $ mconcat
820821 [ "CASE"
821822 , mconcat
@@ -831,16 +832,16 @@ caseWhenThenElse whenThens else_ = UnsafeExpression $ mconcat
831832
832833-- | >>> :{
833834-- let
834−-- expression :: Expression grp commons schemas params from (nullity 'PGint2)
835+-- expression :: Expression outer grp commons schemas params from (nullity 'PGint2)
835836-- expression = ifThenElse true 1 0
836837-- in printSQL expression
837838-- :}
838839-- CASE WHEN TRUE THEN 1 ELSE 0 END
839840ifThenElse
840− :: Condition grp commons schemas params from
841− -> Expression grp commons schemas params from ty -- ^ then
842− -> Expression grp commons schemas params from ty -- ^ else
843− -> Expression grp commons schemas params from ty
841+ :: Condition outer grp commons schemas params from
842+ -> Expression outer grp commons schemas params from ty -- ^ then
843+ -> Expression outer grp commons schemas params from ty -- ^ else
844+ -> Expression outer grp commons schemas params from ty
844845ifThenElse if_ then_ else_ = caseWhenThenElse [(if_,then_)] else_
845846
846847-- | Comparison operations like `.==`, `./=`, `.>`, `.>=`, `.<` and `.<=`
@@ -849,85 +850,85 @@ ifThenElse if_ then_ else_ = caseWhenThenElse [(if_,then_)] else_
849850-- >>> printSQL $ true .== null_
850851-- (TRUE = NULL)
851852(.==)
852− :: Expression grp commons schemas params from (nullity0 ty) -- ^ lhs
853− -> Expression grp commons schemas params from (nullity1 ty) -- ^ rhs
854− -> Condition grp commons schemas params from
853+ :: Expression outer grp commons schemas params from (nullity0 ty) -- ^ lhs
854+ -> Expression outer grp commons schemas params from (nullity1 ty) -- ^ rhs
855+ -> Condition outer grp commons schemas params from
855856(.==) = unsafeBinaryOp "="
856857infix 4 .==
857858
858859-- | >>> printSQL $ true ./= null_
859860-- (TRUE <> NULL)
860861(./=)
861− :: Expression grp commons schemas params from (nullity0 ty) -- ^ lhs
862− -> Expression grp commons schemas params from (nullity1 ty) -- ^ rhs
863− -> Condition grp commons schemas params from
862+ :: Expression outer grp commons schemas params from (nullity0 ty) -- ^ lhs
863+ -> Expression outer grp commons schemas params from (nullity1 ty) -- ^ rhs
864+ -> Condition outer grp commons schemas params from
864865(./=) = unsafeBinaryOp "<>"
865866infix 4 ./=
866867
867868-- | >>> printSQL $ true .>= null_
868869-- (TRUE >= NULL)
869870(.>=)
870− :: Expression grp commons schemas params from (nullity0 ty) -- ^ lhs
871− -> Expression grp commons schemas params from (nullity1 ty) -- ^ rhs
872− -> Condition grp commons schemas params from
871+ :: Expression outer grp commons schemas params from (nullity0 ty) -- ^ lhs
872+ -> Expression outer grp commons schemas params from (nullity1 ty) -- ^ rhs
873+ -> Condition outer grp commons schemas params from
873874(.>=) = unsafeBinaryOp ">="
874875infix 4 .>=
875876
876877-- | >>> printSQL $ true .< null_
877878-- (TRUE < NULL)
878879(.<)
879− :: Expression grp commons schemas params from (nullity0 ty) -- ^ lhs
880− -> Expression grp commons schemas params from (nullity1 ty) -- ^ rhs
881− -> Condition grp commons schemas params from
880+ :: Expression outer grp commons schemas params from (nullity0 ty) -- ^ lhs
881+ -> Expression outer grp commons schemas params from (nullity1 ty) -- ^ rhs
882+ -> Condition outer grp commons schemas params from
882883(.<) = unsafeBinaryOp "<"
883884infix 4 .<
884885
885886-- | >>> printSQL $ true .<= null_
886887-- (TRUE <= NULL)
887888(.<=)
888− :: Expression grp commons schemas params from (nullity0 ty) -- ^ lhs
889− -> Expression grp commons schemas params from (nullity1 ty) -- ^ rhs
890− -> Condition grp commons schemas params from
889+ :: Expression outer grp commons schemas params from (nullity0 ty) -- ^ lhs
890+ -> Expression outer grp commons schemas params from (nullity1 ty) -- ^ rhs
891+ -> Condition outer grp commons schemas params from
891892(.<=) = unsafeBinaryOp "<="
892893infix 4 .<=
893894
894895-- | >>> printSQL $ true .> null_
895896-- (TRUE > NULL)
896897(.>)
897− :: Expression grp commons schemas params from (nullity0 ty) -- ^ lhs
898− -> Expression grp commons schemas params from (nullity1 ty) -- ^ rhs
899− -> Condition grp commons schemas params from
898+ :: Expression outer grp commons schemas params from (nullity0 ty) -- ^ lhs
899+ -> Expression outer grp commons schemas params from (nullity1 ty) -- ^ rhs
900+ -> Condition outer grp commons schemas params from
900901(.>) = unsafeBinaryOp ">"
901902infix 4 .>
902903
903904-- | >>> printSQL currentDate
904905-- CURRENT_DATE
905906currentDate
906− :: Expression grp commons schemas params from (nullity 'PGdate)
907+ :: Expression outer grp commons schemas params from (nullity 'PGdate)
907908currentDate = UnsafeExpression "CURRENT_DATE"
908909
909910-- | >>> printSQL currentTime
910911-- CURRENT_TIME
911912currentTime
912− :: Expression grp commons schemas params from (nullity 'PGtimetz)
913+ :: Expression outer grp commons schemas params from (nullity 'PGtimetz)
913914currentTime = UnsafeExpression "CURRENT_TIME"
914915
915916-- | >>> printSQL currentTimestamp
916917-- CURRENT_TIMESTAMP
917918currentTimestamp
918− :: Expression grp commons schemas params from (nullity 'PGtimestamptz)
919+ :: Expression outer grp commons schemas params from (nullity 'PGtimestamptz)
919920currentTimestamp = UnsafeExpression "CURRENT_TIMESTAMP"
920921
921922-- | >>> printSQL localTime
922923-- LOCALTIME
923924localTime
924− :: Expression grp commons schemas params from (nullity 'PGtime)
925+ :: Expression outer grp commons schemas params from (nullity 'PGtime)
925926localTime = UnsafeExpression "LOCALTIME"
926927
927928-- | >>> printSQL localTimestamp
928929-- LOCALTIMESTAMP
929930localTimestamp
930− :: Expression grp commons schemas params from (nullity 'PGtimestamp)
931+ :: Expression outer grp commons schemas params from (nullity 'PGtimestamp)
931932localTimestamp = UnsafeExpression "LOCALTIMESTAMP"
932933
933934{-----------------------------------------
@@ -935,7 +936,7 @@ text
935936-----------------------------------------}
936937
937938instance IsString
938− (Expression grp commons schemas params from (nullity 'PGtext)) where
939+ (Expression outer grp commons schemas params from (nullity 'PGtext)) where
939940 fromString str = UnsafeExpression $
940941 "E\'" <> fromString (escape =<< str) <> "\'"
941942 where
@@ -951,36 +952,36 @@ instance IsString
951952 c -> [c]
952953
953954instance Semigroup
954− (Expression grp commons schemas params from (nullity 'PGtext)) where
955+ (Expression outer grp commons schemas params from (nullity 'PGtext)) where
955956 (<>) = unsafeBinaryOp "||"
956957
957958instance Monoid
958− (Expression grp commons schemas params from (nullity 'PGtext)) where
959+ (Expression outer grp commons schemas params from (nullity 'PGtext)) where
959960 mempty = fromString ""
960961 mappend = (<>)
961962
962963-- | >>> printSQL $ lower "ARRRGGG"
963964-- lower(E'ARRRGGG')
964965lower
965− :: Expression grp commons schemas params from (nullity 'PGtext)
966+ :: Expression outer grp commons schemas params from (nullity 'PGtext)
966967 -- ^ string to lower case
967− -> Expression grp commons schemas params from (nullity 'PGtext)
968+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
968969lower = unsafeFunction "lower"
969970
970971-- | >>> printSQL $ upper "eeee"
971972-- upper(E'eeee')
972973upper
973− :: Expression grp commons schemas params from (nullity 'PGtext)
974+ :: Expression outer grp commons schemas params from (nullity 'PGtext)
974975 -- ^ string to upper case
975− -> Expression grp commons schemas params from (nullity 'PGtext)
976+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
976977upper = unsafeFunction "upper"
977978
978979-- | >>> printSQL $ charLength "four"
979980-- char_length(E'four')
980981charLength
981− :: Expression grp commons schemas params from (nullity 'PGtext)
982+ :: Expression outer grp commons schemas params from (nullity 'PGtext)
982983 -- ^ string to measure
983− -> Expression grp commons schemas params from (nullity 'PGint4)
984+ -> Expression outer grp commons schemas params from (nullity 'PGint4)
984985charLength = unsafeFunction "char_length"
985986
986987-- | The `like` expression returns true if the @string@ matches
@@ -993,11 +994,11 @@ charLength = unsafeFunction "char_length"
993994-- >>> printSQL $ "abc" `like` "a%"
994995-- (E'abc' LIKE E'a%')
995996like
996− :: Expression grp commons schemas params from (nullity 'PGtext)
997+ :: Expression outer grp commons schemas params from (nullity 'PGtext)
997998 -- ^ string
998− -> Expression grp commons schemas params from (nullity 'PGtext)
999+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
9991000 -- ^ pattern
1000− -> Expression grp commons schemas params from (nullity 'PGbool)
1001+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
10011002like = unsafeBinaryOp "LIKE"
10021003
10031004-- | The key word ILIKE can be used instead of LIKE to make the
@@ -1006,11 +1007,11 @@ like = unsafeBinaryOp "LIKE"
10061007-- >>> printSQL $ "abc" `ilike` "a%"
10071008-- (E'abc' ILIKE E'a%')
10081009ilike
1009− :: Expression grp commons schemas params from (nullity 'PGtext)
1010+ :: Expression outer grp commons schemas params from (nullity 'PGtext)
10101011 -- ^ string
1011− -> Expression grp commons schemas params from (nullity 'PGtext)
1012+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
10121013 -- ^ pattern
1013− -> Expression grp commons schemas params from (nullity 'PGbool)
1014+ -> Expression outer grp commons schemas params from (nullity 'PGbool)
10141015ilike = unsafeBinaryOp "ILIKE"
10151016
10161017{-----------------------------------------
@@ -1025,36 +1026,36 @@ Table 9.44: json and jsonb operators
10251026-- | Get JSON value (object field or array element) at a key.
10261027(.->)
10271028 :: (json `In` PGJsonType, key `In` PGJsonKey)
1028− => Expression grp commons schemas params from (nullity json)
1029− -> Expression grp commons schemas params from (nullity key)
1030− -> Expression grp commons schemas params from ('Null json)
1029+ => Expression outer grp commons schemas params from (nullity json)
1030+ -> Expression outer grp commons schemas params from (nullity key)
1031+ -> Expression outer grp commons schemas params from ('Null json)
10311032infixl 8 .->
10321033(.->) = unsafeBinaryOp "->"
10331034
10341035-- | Get JSON value (object field or array element) at a key, as text.
10351036(.->>)
10361037 :: (json `In` PGJsonType, key `In` PGJsonKey)
1037− => Expression grp commons schemas params from (nullity json)
1038− -> Expression grp commons schemas params from (nullity key)
1039− -> Expression grp commons schemas params from ('Null 'PGtext)
1038+ => Expression outer grp commons schemas params from (nullity json)
1039+ -> Expression outer grp commons schemas params from (nullity key)
1040+ -> Expression outer grp commons schemas params from ('Null 'PGtext)
10401041infixl 8 .->>
10411042(.->>) = unsafeBinaryOp "->>"
10421043
10431044-- | Get JSON value at a specified path.
10441045(.#>)
10451046 :: (json `In` PGJsonType, PGTextArray "(.#>)" path)
1046− => Expression grp commons schemas params from (nullity json)
1047− -> Expression grp commons schemas params from (nullity path)
1048− -> Expression grp commons schemas params from ('Null json)
1047+ => Expression outer grp commons schemas params from (nullity json)
1048+ -> Expression outer grp commons schemas params from (nullity path)
1049+ -> Expression outer grp commons schemas params from ('Null json)
10491050infixl 8 .#>
10501051(.#>) = unsafeBinaryOp "#>"
10511052
10521053-- | Get JSON value at a specified path as text.
10531054(.#>>)
10541055 :: (json `In` PGJsonType, PGTextArray "(.#>>)" path)
1055− => Expression grp commons schemas params from (nullity json)
1056− -> Expression grp commons schemas params from (nullity path)
1057− -> Expression grp commons schemas params from ('Null 'PGtext)
1056+ => Expression outer grp commons schemas params from (nullity json)
1057+ -> Expression outer grp commons schemas params from (nullity path)
1058+ -> Expression outer grp commons schemas params from ('Null 'PGtext)
10581059infixl 8 .#>>
10591060(.#>>) = unsafeBinaryOp "#>>"
10601061
@@ -1063,49 +1064,49 @@ infixl 8 .#>>
10631064-- | Does the left JSON value contain the right JSON path/value entries at the
10641065-- top level?
10651066(.@>)
1066− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1067− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1068− -> Condition grp commons schemas params from
1067+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1068+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1069+ -> Condition outer grp commons schemas params from
10691070infixl 9 .@>
10701071(.@>) = unsafeBinaryOp "@>"
10711072
10721073-- | Are the left JSON path/value entries contained at the top level within the
10731074-- right JSON value?
10741075(.<@)
1075− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1076− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1077− -> Condition grp commons schemas params from
1076+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1077+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1078+ -> Condition outer grp commons schemas params from
10781079infixl 9 .<@
10791080(.<@) = unsafeBinaryOp "<@"
10801081
10811082-- | Does the string exist as a top-level key within the JSON value?
10821083(.?)
1083− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1084− -> Expression grp commons schemas params from (nullity 'PGtext)
1085− -> Condition grp commons schemas params from
1084+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1085+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
1086+ -> Condition outer grp commons schemas params from
10861087infixl 9 .?
10871088(.?) = unsafeBinaryOp "?"
10881089
10891090-- | Do any of these array strings exist as top-level keys?
10901091(.?|)
1091− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1092− -> Expression grp commons schemas params from (nullity ('PGvararray ('NotNull 'PGtext)))
1093− -> Condition grp commons schemas params from
1092+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1093+ -> Expression outer grp commons schemas params from (nullity ('PGvararray ('NotNull 'PGtext)))
1094+ -> Condition outer grp commons schemas params from
10941095infixl 9 .?|
10951096(.?|) = unsafeBinaryOp "?|"
10961097
10971098-- | Do all of these array strings exist as top-level keys?
10981099(.?&)
1099− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1100− -> Expression grp commons schemas params from (nullity ('PGvararray ('NotNull 'PGtext)))
1101− -> Condition grp commons schemas params from
1100+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1101+ -> Expression outer grp commons schemas params from (nullity ('PGvararray ('NotNull 'PGtext)))
1102+ -> Condition outer grp commons schemas params from
11021103infixl 9 .?&
11031104(.?&) = unsafeBinaryOp "?&"
11041105
11051106-- | Concatenate two jsonb values into a new jsonb value.
1106−instance
1107− Semigroup (Expression commons schemas from grouping param (nullity 'PGjsonb)) where
1108− (<>) = unsafeBinaryOp "||"
1107+instance Semigroup
1108+ (Expression outer grp commons schemas params from (nullity 'PGjsonb)) where
1109+ (<>) = unsafeBinaryOp "||"
11091110
11101111-- | Delete a key or keys from a JSON object, or remove an array element.
11111112--
@@ -1121,9 +1122,9 @@ instance
11211122-- count from the end). Throws an error if top level container is not an array.
11221123(.-.)
11231124 :: (key `In` '[ 'PGtext, 'PGvararray ('NotNull 'PGtext), 'PGint4, 'PGint2 ]) -- hlint error without parens here
1124− => Expression grp commons schemas params from (nullity 'PGjsonb)
1125− -> Expression grp commons schemas params from (nullity key)
1126− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1125+ => Expression outer grp commons schemas params from (nullity 'PGjsonb)
1126+ -> Expression outer grp commons schemas params from (nullity key)
1127+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
11271128infixl 6 .-.
11281129(.-.) = unsafeBinaryOp "-"
11291130
@@ -1131,9 +1132,9 @@ infixl 6 .-.
11311132-- integers count from the end)
11321133(#-.)
11331134 :: PGTextArray "(#-.)" arrayty
1134− => Expression grp commons schemas params from (nullity 'PGjsonb)
1135− -> Expression grp commons schemas params from (nullity arrayty)
1136− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1135+ => Expression outer grp commons schemas params from (nullity 'PGjsonb)
1136+ -> Expression outer grp commons schemas params from (nullity arrayty)
1137+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
11371138infixl 6 #-.
11381139(#-.) = unsafeBinaryOp "#-"
11391140
@@ -1144,14 +1145,14 @@ Table 9.45: JSON creation functions
11441145-- | Literal binary JSON
11451146jsonbLit
11461147 :: JSON.ToJSON x
1147− => x -> Expression grp commons schemas params from (nullity 'PGjsonb)
1148+ => x -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
11481149jsonbLit = cast jsonb . UnsafeExpression
11491150 . singleQuotedUtf8 . toStrict . JSON.encode
11501151
11511152-- | Literal JSON
11521153jsonLit
11531154 :: JSON.ToJSON x
1154− => x -> Expression grp commons schemas params from (nullity 'PGjson)
1155+ => x -> Expression outer grp commons schemas params from (nullity 'PGjson)
11551156jsonLit = cast json . UnsafeExpression
11561157 . singleQuotedUtf8 . toStrict . JSON.encode
11571158
@@ -1162,8 +1163,8 @@ jsonLit = cast json . UnsafeExpression
11621163-- number, a Boolean, or a null value, the text representation will be used, in
11631164-- such a fashion that it is a valid json value.
11641165toJson
1165− :: Expression grp commons schemas params from (nullity ty)
1166− -> Expression grp commons schemas params from (nullity 'PGjson)
1166+ :: Expression outer grp commons schemas params from (nullity ty)
1167+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
11671168toJson = unsafeFunction "to_json"
11681169
11691170-- | Returns the value as jsonb. Arrays and composites are converted
@@ -1173,43 +1174,43 @@ toJson = unsafeFunction "to_json"
11731174-- number, a Boolean, or a null value, the text representation will be used, in
11741175-- such a fashion that it is a valid jsonb value.
11751176toJsonb
1176− :: Expression grp commons schemas params from (nullity ty)
1177− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1177+ :: Expression outer grp commons schemas params from (nullity ty)
1178+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
11781179toJsonb = unsafeFunction "to_jsonb"
11791180
11801181-- | Returns the array as a JSON array. A PostgreSQL multidimensional array
11811182-- becomes a JSON array of arrays.
11821183arrayToJson
11831184 :: PGArray "arrayToJson" arr
1184− => Expression grp commons schemas params from (nullity arr)
1185− -> Expression grp commons schemas params from (nullity 'PGjson)
1185+ => Expression outer grp commons schemas params from (nullity arr)
1186+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
11861187arrayToJson = unsafeFunction "array_to_json"
11871188
11881189-- | Returns the row as a JSON object.
11891190rowToJson
1190− :: Expression grp commons schemas params from (nullity ('PGcomposite ty))
1191− -> Expression grp commons schemas params from (nullity 'PGjson)
1191+ :: Expression outer grp commons schemas params from (nullity ('PGcomposite ty))
1192+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
11921193rowToJson = unsafeFunction "row_to_json"
11931194
11941195-- | Builds a possibly-heterogeneously-typed JSON array out of a variadic
11951196-- argument list.
11961197jsonBuildArray
11971198 :: SListI elems
1198− => NP (Expression grp commons schemas params from) elems
1199− -> Expression grp commons schemas params from (nullity 'PGjson)
1199+ => NP (Expression outer grp commons schemas params from) elems
1200+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
12001201jsonBuildArray = unsafeVariadicFunction "json_build_array"
12011202
12021203-- | Builds a possibly-heterogeneously-typed (binary) JSON array out of a
12031204-- variadic argument list.
12041205jsonbBuildArray
12051206 :: SListI elems
1206− => NP (Expression grp commons schemas params from) elems
1207− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1207+ => NP (Expression outer grp commons schemas params from) elems
1208+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
12081209jsonbBuildArray = unsafeVariadicFunction "jsonb_build_array"
12091210
12101211unsafeRowFunction
12111212 :: All Top elems
1212− => NP (Aliased (Expression grp commons schemas params from)) elems
1213+ => NP (Aliased (Expression outer grp commons schemas params from)) elems
12131214 -> [ByteString]
12141215unsafeRowFunction =
12151216 (`appEndo` []) . hcfoldMap (Proxy :: Proxy Top)
@@ -1224,8 +1225,8 @@ unsafeRowFunction =
12241225-- and values.
12251226jsonBuildObject
12261227 :: All Top elems
1227− => NP (Aliased (Expression grp commons schemas params from)) elems
1228− -> Expression grp commons schemas params from (nullity 'PGjson)
1228+ => NP (Aliased (Expression outer grp commons schemas params from)) elems
1229+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
12291230jsonBuildObject
12301231 = unsafeFunction "json_build_object"
12311232 . UnsafeExpression
@@ -1237,8 +1238,8 @@ jsonBuildObject
12371238-- between text and values.
12381239jsonbBuildObject
12391240 :: All Top elems
1240− => NP (Aliased (Expression grp commons schemas params from)) elems
1241− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1241+ => NP (Aliased (Expression outer grp commons schemas params from)) elems
1242+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
12421243jsonbBuildObject
12431244 = unsafeFunction "jsonb_build_object"
12441245 . UnsafeExpression
@@ -1251,8 +1252,8 @@ jsonbBuildObject
12511252-- array has exactly two elements, which are taken as a key/value pair.
12521253jsonObject
12531254 :: PGArrayOf "jsonObject" arr ('NotNull 'PGtext)
1254− => Expression grp commons schemas params from (nullity arr)
1255− -> Expression grp commons schemas params from (nullity 'PGjson)
1255+ => Expression outer grp commons schemas params from (nullity arr)
1256+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
12561257jsonObject = unsafeFunction "json_object"
12571258
12581259-- | Builds a binary JSON object out of a text array. The array must have either
@@ -1261,8 +1262,8 @@ jsonObject = unsafeFunction "json_object"
12611262-- array has exactly two elements, which are taken as a key/value pair.
12621263jsonbObject
12631264 :: PGArrayOf "jsonbObject" arr ('NotNull 'PGtext)
1264− => Expression grp commons schemas params from (nullity arr)
1265− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1265+ => Expression outer grp commons schemas params from (nullity arr)
1266+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
12661267jsonbObject = unsafeFunction "jsonb_object"
12671268
12681269-- | This is an alternate form of 'jsonObject' that takes two arrays; one for
@@ -1270,9 +1271,9 @@ jsonbObject = unsafeFunction "jsonb_object"
12701271jsonZipObject
12711272 :: ( PGArrayOf "jsonZipObject" keysArray ('NotNull 'PGtext)
12721273 , PGArrayOf "jsonZipObject" valuesArray ('NotNull 'PGtext))
1273− => Expression grp commons schemas params from (nullity keysArray)
1274− -> Expression grp commons schemas params from (nullity valuesArray)
1275− -> Expression grp commons schemas params from (nullity 'PGjson)
1274+ => Expression outer grp commons schemas params from (nullity keysArray)
1275+ -> Expression outer grp commons schemas params from (nullity valuesArray)
1276+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
12761277jsonZipObject ks vs =
12771278 unsafeVariadicFunction "json_object" (ks :* vs :* Nil)
12781279
@@ -1282,9 +1283,9 @@ jsonZipObject ks vs =
12821283jsonbZipObject
12831284 :: ( PGArrayOf "jsonbZipObject" keysArray ('NotNull 'PGtext)
12841285 , PGArrayOf "jsonbZipObject" valuesArray ('NotNull 'PGtext))
1285− => Expression grp commons schemas params from (nullity keysArray)
1286− -> Expression grp commons schemas params from (nullity valuesArray)
1287− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1286+ => Expression outer grp commons schemas params from (nullity keysArray)
1287+ -> Expression outer grp commons schemas params from (nullity valuesArray)
1288+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
12881289jsonbZipObject ks vs =
12891290 unsafeVariadicFunction "jsonb_object" (ks :* vs :* Nil)
12901291
@@ -1294,23 +1295,23 @@ Table 9.46: JSON processing functions
12941295
12951296-- | Returns the number of elements in the outermost JSON array.
12961297jsonArrayLength
1297− :: Expression grp commons schemas params from (nullity 'PGjson)
1298− -> Expression grp commons schemas params from (nullity 'PGint4)
1298+ :: Expression outer grp commons schemas params from (nullity 'PGjson)
1299+ -> Expression outer grp commons schemas params from (nullity 'PGint4)
12991300jsonArrayLength = unsafeFunction "json_array_length"
13001301
13011302-- | Returns the number of elements in the outermost binary JSON array.
13021303jsonbArrayLength
1303− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1304− -> Expression grp commons schemas params from (nullity 'PGint4)
1304+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1305+ -> Expression outer grp commons schemas params from (nullity 'PGint4)
13051306jsonbArrayLength = unsafeFunction "jsonb_array_length"
13061307
13071308-- | Returns JSON value pointed to by the given path (equivalent to #>
13081309-- operator).
13091310jsonExtractPath
13101311 :: SListI elems
1311− => Expression grp commons schemas params from (nullity 'PGjson)
1312− -> NP (Expression grp commons schemas params from) elems
1313− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1312+ => Expression outer grp commons schemas params from (nullity 'PGjson)
1313+ -> NP (Expression outer grp commons schemas params from) elems
1314+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
13141315jsonExtractPath x xs =
13151316 unsafeVariadicFunction "json_extract_path" (x :* xs)
13161317
@@ -1318,9 +1319,9 @@ jsonExtractPath x xs =
13181319-- operator).
13191320jsonbExtractPath
13201321 :: SListI elems
1321− => Expression grp commons schemas params from (nullity 'PGjsonb)
1322− -> NP (Expression grp commons schemas params from) elems
1323− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1322+ => Expression outer grp commons schemas params from (nullity 'PGjsonb)
1323+ -> NP (Expression outer grp commons schemas params from) elems
1324+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
13241325jsonbExtractPath x xs =
13251326 unsafeVariadicFunction "jsonb_extract_path" (x :* xs)
13261327
@@ -1328,9 +1329,9 @@ jsonbExtractPath x xs =
13281329-- operator), as text.
13291330jsonExtractPathAsText
13301331 :: SListI elems
1331− => Expression grp commons schemas params from (nullity 'PGjson)
1332− -> NP (Expression grp commons schemas params from) elems
1333− -> Expression grp commons schemas params from (nullity 'PGjson)
1332+ => Expression outer grp commons schemas params from (nullity 'PGjson)
1333+ -> NP (Expression outer grp commons schemas params from) elems
1334+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
13341335jsonExtractPathAsText x xs =
13351336 unsafeVariadicFunction "json_extract_path_text" (x :* xs)
13361337
@@ -1338,38 +1339,38 @@ jsonExtractPathAsText x xs =
13381339-- operator), as text.
13391340jsonbExtractPathAsText
13401341 :: SListI elems
1341− => Expression grp commons schemas params from (nullity 'PGjsonb)
1342− -> NP (Expression grp commons schemas params from) elems
1343− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1342+ => Expression outer grp commons schemas params from (nullity 'PGjsonb)
1343+ -> NP (Expression outer grp commons schemas params from) elems
1344+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
13441345jsonbExtractPathAsText x xs =
13451346 unsafeVariadicFunction "jsonb_extract_path_text" (x :* xs)
13461347
13471348-- | Returns the type of the outermost JSON value as a text string. Possible
13481349-- types are object, array, string, number, boolean, and null.
13491350jsonTypeof
1350− :: Expression grp commons schemas params from (nullity 'PGjson)
1351− -> Expression grp commons schemas params from (nullity 'PGtext)
1351+ :: Expression outer grp commons schemas params from (nullity 'PGjson)
1352+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
13521353jsonTypeof = unsafeFunction "json_typeof"
13531354
13541355-- | Returns the type of the outermost binary JSON value as a text string.
13551356-- Possible types are object, array, string, number, boolean, and null.
13561357jsonbTypeof
1357− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1358− -> Expression grp commons schemas params from (nullity 'PGtext)
1358+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1359+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
13591360jsonbTypeof = unsafeFunction "jsonb_typeof"
13601361
13611362-- | Returns its argument with all object fields that have null values omitted.
13621363-- Other null values are untouched.
13631364jsonStripNulls
1364− :: Expression grp commons schemas params from (nullity 'PGjson)
1365− -> Expression grp commons schemas params from (nullity 'PGjson)
1365+ :: Expression outer grp commons schemas params from (nullity 'PGjson)
1366+ -> Expression outer grp commons schemas params from (nullity 'PGjson)
13661367jsonStripNulls = unsafeFunction "json_strip_nulls"
13671368
13681369-- | Returns its argument with all object fields that have null values omitted.
13691370-- Other null values are untouched.
13701371jsonbStripNulls
1371− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1372− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1372+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1373+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
13731374jsonbStripNulls = unsafeFunction "jsonb_strip_nulls"
13741375
13751376-- | @ jsonbSet target path new_value create_missing @
@@ -1381,11 +1382,11 @@ jsonbStripNulls = unsafeFunction "jsonb_strip_nulls"
13811382-- arrays.
13821383jsonbSet
13831384 :: PGTextArray "jsonbSet" arr
1384− => Expression grp commons schemas params from (nullity 'PGjsonb)
1385− -> Expression grp commons schemas params from (nullity arr)
1386− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1387− -> Maybe (Expression grp commons schemas params from (nullity 'PGbool))
1388− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1385+ => Expression outer grp commons schemas params from (nullity 'PGjsonb)
1386+ -> Expression outer grp commons schemas params from (nullity arr)
1387+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1388+ -> Maybe (Expression outer grp commons schemas params from (nullity 'PGbool))
1389+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
13891390jsonbSet tgt path val createMissing = case createMissing of
13901391 Just m -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* m :* Nil)
13911392 Nothing -> unsafeVariadicFunction "jsonb_set" (tgt :* path :* val :* Nil)
@@ -1400,19 +1401,19 @@ jsonbSet tgt path val createMissing = case createMissing of
14001401-- in path count from the end of JSON arrays.
14011402jsonbInsert
14021403 :: PGTextArray "jsonbInsert" arr
1403− => Expression grp commons schemas params from (nullity 'PGjsonb)
1404− -> Expression grp commons schemas params from (nullity arr)
1405− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1406− -> Maybe (Expression grp commons schemas params from (nullity 'PGbool))
1407− -> Expression grp commons schemas params from (nullity 'PGjsonb)
1404+ => Expression outer grp commons schemas params from (nullity 'PGjsonb)
1405+ -> Expression outer grp commons schemas params from (nullity arr)
1406+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
1407+ -> Maybe (Expression outer grp commons schemas params from (nullity 'PGbool))
1408+ -> Expression outer grp commons schemas params from (nullity 'PGjsonb)
14081409jsonbInsert tgt path val insertAfter = case insertAfter of
14091410 Just i -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* i :* Nil)
14101411 Nothing -> unsafeVariadicFunction "jsonb_insert" (tgt :* path :* val :* Nil)
14111412
14121413-- | Returns its argument as indented JSON text.
14131414jsonbPretty
1414− :: Expression grp commons schemas params from (nullity 'PGjsonb)
1415− -> Expression grp commons schemas params from (nullity 'PGtext)
1415+ :: Expression outer grp commons schemas params from (nullity 'PGjsonb)
1416+ -> Expression outer grp commons schemas params from (nullity 'PGtext)
14161417jsonbPretty = unsafeFunction "jsonb_pretty"
14171418
14181419{-----------------------------------------
@@ -1426,7 +1427,7 @@ class Aggregate expr1 expr2 aggr
14261427 --
14271428 -- >>> :{
14281429 -- let
1429− -- expression :: Expression (Grouped bys) commons schemas params from ('NotNull 'PGint8)
1430+ -- expression :: Expression '[] ('Grouped bys) commons schemas params from ('NotNull 'PGint8)
14301431 -- expression = countStar
14311432 -- in printSQL expression
14321433 -- :}
@@ -1435,7 +1436,7 @@ class Aggregate expr1 expr2 aggr
14351436
14361437 -- | >>> :{
14371438 -- let
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)
14391440 -- expression = count (All #col)
14401441 -- in printSQL expression
14411442 -- :}
@@ -1447,7 +1448,7 @@ class Aggregate expr1 expr2 aggr
14471448
14481449 -- | >>> :{
14491450 -- let
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)
14511452 -- expression = sum_ (Distinct #col)
14521453 -- in printSQL expression
14531454 -- :}
@@ -1462,9 +1463,19 @@ class Aggregate expr1 expr2 aggr
14621463 :: expr1 ty
14631464 -> aggr ('NotNull ('PGvararray ty))
14641465
1466+ -- | aggregates values as a JSON array
1467+ jsonAgg
1468+ :: expr1 ty
1469+ -> aggr ('NotNull 'PGjson)
1470+
1471+ -- | aggregates values as a JSON array
1472+ jsonbAgg
1473+ :: expr1 ty
1474+ -> aggr ('NotNull 'PGjsonb)
1475+
14651476 -- | >>> :{
14661477 -- let
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)
14681479 -- expression = bitAnd (Distinct #col)
14691480 -- in printSQL expression
14701481 -- :}
@@ -1477,7 +1488,7 @@ class Aggregate expr1 expr2 aggr
14771488
14781489 -- | >>> :{
14791490 -- let
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)
14811492 -- expression = bitOr (All #col)
14821493 -- in printSQL expression
14831494 -- :}
@@ -1490,7 +1501,7 @@ class Aggregate expr1 expr2 aggr
14901501
14911502 -- | >>> :{
14921503 -- let
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)
14941505 -- winFun = boolAnd #col
14951506 -- in printSQL winFun
14961507 -- :}
@@ -1502,7 +1513,7 @@ class Aggregate expr1 expr2 aggr
15021513
15031514 -- | >>> :{
15041515 -- let
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)
15061517 -- expression = boolOr (All #col)
15071518 -- in printSQL expression
15081519 -- :}
@@ -1516,7 +1527,7 @@ class Aggregate expr1 expr2 aggr
15161527 --
15171528 -- >>> :{
15181529 -- let
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)
15201531 -- expression = every (Distinct #col)
15211532 -- in printSQL expression
15221533 -- :}
@@ -1537,7 +1548,7 @@ class Aggregate expr1 expr2 aggr
15371548 :: expr1 (nullity ty)
15381549 -- ^ what to minimize
15391550 -> aggr (nullity ty)
1540−
1551+
15411552 -- | average aggregation
15421553 avg
15431554 :: expr1 (nullity ty)
@@ -1547,7 +1558,7 @@ class Aggregate expr1 expr2 aggr
15471558 {- | correlation coefficient
15481559 >>> :{
15491560 let
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)
15511562 expression = corr (All (#y :*: #x))
15521563 in printSQL expression
15531564 :}
@@ -1560,7 +1571,7 @@ class Aggregate expr1 expr2 aggr
15601571 {- | population covariance
15611572 >>> :{
15621573 let
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)
15641575 expression = covarPop (All (#y :*: #x))
15651576 in printSQL expression
15661577 :}
@@ -1573,7 +1584,7 @@ class Aggregate expr1 expr2 aggr
15731584 {- | sample covariance
15741585 >>> :{
15751586 let
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)
15771588 winFun = covarSamp (#y :*: #x)
15781589 in printSQL winFun
15791590 :}
@@ -1586,7 +1597,7 @@ class Aggregate expr1 expr2 aggr
15861597 {- | average of the independent variable (sum(X)/N)
15871598 >>> :{
15881599 let
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)
15901601 expression = regrAvgX (All (#y :*: #x))
15911602 in printSQL expression
15921603 :}
@@ -1599,7 +1610,7 @@ class Aggregate expr1 expr2 aggr
15991610 {- | average of the dependent variable (sum(Y)/N)
16001611 >>> :{
16011612 let
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)
16031614 winFun = regrAvgY (#y :*: #x)
16041615 in printSQL winFun
16051616 :}
@@ -1612,7 +1623,7 @@ class Aggregate expr1 expr2 aggr
16121623 {- | number of input rows in which both expressions are nonnull
16131624 >>> :{
16141625 let
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)
16161627 winFun = regrCount (#y :*: #x)
16171628 in printSQL winFun
16181629 :}
@@ -1625,7 +1636,7 @@ class Aggregate expr1 expr2 aggr
16251636 {- | y-intercept of the least-squares-fit linear equation determined by the (X, Y) pairs
16261637 >>> :{
16271638 let
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)
16291640 expression = regrIntercept (All (#y :*: #x))
16301641 in printSQL expression
16311642 :}
@@ -1663,27 +1674,27 @@ class Aggregate expr1 expr2 aggr
16631674 regrSyy
16641675 :: expr2 (nullity 'PGfloat8)
16651676 -> aggr (nullity 'PGfloat8)
1666−
1677+
16671678 -- | historical alias for `stddevSamp`
16681679 stddev
16691680 :: expr1 (nullity ty)
16701681 -> aggr (nullity (PGAvg ty))
1671−
1682+
16721683 -- | population standard deviation of the input values
16731684 stddevPop
16741685 :: expr1 (nullity ty)
16751686 -> aggr (nullity (PGAvg ty))
1676−
1687+
16771688 -- | sample standard deviation of the input values
16781689 stddevSamp
16791690 :: expr1 (nullity ty)
16801691 -> aggr (nullity (PGAvg ty))
1681−
1692+
16821693 -- | historical alias for `varSamp`
16831694 variance
16841695 :: expr1 (nullity ty)
16851696 -> aggr (nullity (PGAvg ty))
1686−
1697+
16871698 -- | population variance of the input values
16881699 -- (square of the population standard deviation)
16891700 varPop
@@ -1700,16 +1711,16 @@ data Distinction expr ty
17001711 = All (expr ty)
17011712 | Distinct (expr ty)
17021713 deriving (GHC.Generic,Show,Eq,Ord)
1703−instance NFData (Distinction (Expression grp commons schemas params from) ty)
1704−instance RenderSQL (Distinction (Expression grp commons schemas params from) ty) where
1714+instance NFData (Distinction (Expression outer grp commons schemas params from) ty)
1715+instance RenderSQL (Distinction (Expression outer grp commons schemas params from) ty) where
17051716 renderSQL = \case
17061717 All x -> "ALL" <+> renderSQL x
17071718 Distinct x -> "DISTINCT" <+> renderSQL x
17081719instance RenderSQL
17091720 (Distinction
1710− ( Expression grp commons schemas params from
1721+ ( Expression outer grp commons schemas params from
17111722 :*:
1712− Expression grp commons schemas params from) xty ) where
1723+ Expression outer grp commons schemas params from) xty ) where
17131724 renderSQL = \case
17141725 All (x :*: x') ->
17151726 "ALL" <+> renderSQL x <> ", " <> renderSQL x'
@@ -1717,13 +1728,15 @@ instance RenderSQL
17171728 "DISTINCT" <+> renderSQL x <> ", " <> renderSQL x'
17181729
17191730instance Aggregate
1720− (Distinction (Expression 'Ungrouped commons schemas params from))
1721− (Distinction (Expression 'Ungrouped commons schemas params from :*: Expression 'Ungrouped commons schemas params from))
1722− (Expression ('Grouped bys) commons schemas params from) where
1731+ (Distinction (Expression outer 'Ungrouped commons schemas params from))
1732+ (Distinction (Expression outer 'Ungrouped commons schemas params from :*: Expression outer 'Ungrouped commons schemas params from))
1733+ (Expression outer ('Grouped bys) commons schemas params from) where
17231734 countStar = UnsafeExpression "count(*)"
17241735 count = unsafeAggregate1 "count"
17251736 sum_ = unsafeAggregate1 "sum"
17261737 arrayAgg = unsafeAggregate1 "array_agg"
1738+ jsonAgg = unsafeAggregate1 "json_agg"
1739+ jsonbAgg = unsafeAggregate1 "jsonb_agg"
17271740 bitAnd = unsafeAggregate1 "bit_and"
17281741 bitOr = unsafeAggregate1 "bit_or"
17291742 boolAnd = unsafeAggregate1 "bool_and"
@@ -1751,13 +1764,15 @@ instance Aggregate
17511764 varPop = unsafeAggregate1 "var_pop"
17521765 varSamp = unsafeAggregate1 "var_samp"
17531766instance Aggregate
1754− (Expression grp commons schemas params from)
1755− (Expression grp commons schemas params from :*: Expression grp commons schemas params from)
1756− (WindowFunction grp commons schemas params from) where
1767+ (Expression outer grp commons schemas params from)
1768+ (Expression outer grp commons schemas params from :*: Expression outer grp commons schemas params from)
1769+ (WindowFunction outer grp commons schemas params from) where
17571770 countStar = UnsafeWindowFunction "count(*)"
17581771 count = unsafeWindowFunction1 "count"
17591772 sum_ = unsafeWindowFunction1 "sum"
17601773 arrayAgg = unsafeWindowFunction1 "array_agg"
1774+ jsonAgg = unsafeWindowFunction1 "json_agg"
1775+ jsonbAgg = unsafeWindowFunction1 "jsonb_agg"
17611776 bitAnd = unsafeWindowFunction1 "bit_and"
17621777 bitOr = unsafeWindowFunction1 "bit_or"
17631778 boolAnd = unsafeWindowFunction1 "bool_and"
@@ -1788,16 +1803,16 @@ instance Aggregate
17881803-- | escape hatch to define aggregate functions
17891804unsafeAggregate1
17901805 :: ByteString -- ^ aggregate function
1791− -> Distinction (Expression 'Ungrouped commons schemas params from) xty
1792− -> Expression ('Grouped bys) commons schemas params from yty
1806+ -> Distinction (Expression outer 'Ungrouped commons schemas params from) xty
1807+ -> Expression outer ('Grouped bys) commons schemas params from yty
17931808unsafeAggregate1 fun x = UnsafeExpression $ mconcat
17941809 [fun, "(", renderSQL x, ")"]
17951810
17961811-- | escape hatch to define aggregate binary functions
17971812unsafeAggregate2
17981813 :: ByteString -- ^ aggregate function
1799− -> Distinction (Expression 'Ungrouped commons schemas params from :*: Expression 'Ungrouped commons schemas params from) xty
1800− -> Expression ('Grouped bys) commons schemas params from yty
1814+ -> Distinction (Expression outer 'Ungrouped commons schemas params from :*: Expression outer 'Ungrouped commons schemas params from) xty
1815+ -> Expression outer ('Grouped bys) commons schemas params from yty
18011816unsafeAggregate2 fun xx = UnsafeExpression $ mconcat
18021817 [fun, "(", renderSQL xx, ")"]
18031818
@@ -1993,35 +2008,35 @@ Sorting
19932008-- `AscNullsLast`, `DescNullsFirst` and `DescNullsLast` options are used to
19942009-- determine whether nulls appear before or after non-null values in the sort
19952010-- 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
19972012 Asc
1998− :: Expression grp commons schemas params from ('NotNull ty)
1999− -> SortExpression grp commons schemas params from
2013+ :: Expression outer grp commons schemas params from ('NotNull ty)
2014+ -> SortExpression outer grp commons schemas params from
20002015 Desc
2001− :: Expression grp commons schemas params from ('NotNull ty)
2002− -> SortExpression grp commons schemas params from
2016+ :: Expression outer grp commons schemas params from ('NotNull ty)
2017+ -> SortExpression outer grp commons schemas params from
20032018 AscNullsFirst
2004− :: Expression grp commons schemas params from ('Null ty)
2005− -> SortExpression grp commons schemas params from
2019+ :: Expression outer grp commons schemas params from ('Null ty)
2020+ -> SortExpression outer grp commons schemas params from
20062021 AscNullsLast
2007− :: Expression grp commons schemas params from ('Null ty)
2008− -> SortExpression grp commons schemas params from
2022+ :: Expression outer grp commons schemas params from ('Null ty)
2023+ -> SortExpression outer grp commons schemas params from
20092024 DescNullsFirst
2010− :: Expression grp commons schemas params from ('Null ty)
2011− -> SortExpression grp commons schemas params from
2025+ :: Expression outer grp commons schemas params from ('Null ty)
2026+ -> SortExpression outer grp commons schemas params from
20122027 DescNullsLast
2013− :: Expression grp commons schemas params from ('Null ty)
2014− -> SortExpression grp commons schemas params from
2015−deriving instance Show (SortExpression grp commons schemas params from)
2028+ :: Expression outer grp commons schemas params from ('Null ty)
2029+ -> SortExpression outer grp commons schemas params from
2030+deriving instance Show (SortExpression outer grp commons schemas params from)
20162031
20172032class OrderBy expr where
20182033 orderBy
2019− :: [SortExpression grp commons schemas params from]
2020− -> expr grp commons schemas params from
2021− -> expr grp commons schemas params from
2034+ :: [SortExpression outer grp commons schemas params from]
2035+ -> expr outer grp commons schemas params from
2036+ -> expr outer grp commons schemas params from
20222037
20232038-- | Render a `SortExpression`.
2024−instance RenderSQL (SortExpression grp commons schemas params from) where
2039+instance RenderSQL (SortExpression outer grp commons schemas params from) where
20252040 renderSQL = \case
20262041 Asc expression -> renderSQL expression <+> "ASC"
20272042 Desc expression -> renderSQL expression <+> "DESC"
@@ -2032,18 +2047,18 @@ instance RenderSQL (SortExpression grp commons schemas params from) where
20322047 AscNullsLast expression -> renderSQL expression <+> "ASC NULLS LAST"
20332048 DescNullsLast expression -> renderSQL expression <+> "DESC NULLS LAST"
20342049
2035−data WindowDefinition grp commons schemas params from where
2050+data WindowDefinition outer grp commons schemas params from where
20362051 WindowDefinition
20372052 :: SListI bys
2038− => NP (Expression grp commons schemas params from) bys
2039− -> [SortExpression grp commons schemas params from]
2040− -> WindowDefinition grp commons schemas params from
2053+ => NP (Expression outer grp commons schemas params from) bys
2054+ -> [SortExpression outer grp commons schemas params from]
2055+ -> WindowDefinition outer grp commons schemas params from
20412056
20422057instance OrderBy WindowDefinition where
20432058 orderBy sortsR (WindowDefinition parts sortsL)
20442059 = WindowDefinition parts (sortsL ++ sortsR)
20452060
2046−instance RenderSQL (WindowDefinition commons schemas from grp params) where
2061+instance RenderSQL (WindowDefinition outer commons schemas from grp params) where
20472062 renderSQL (WindowDefinition part ord) =
20482063 renderPartitionByClause part <> renderOrderByClause ord
20492064 where
@@ -2057,11 +2072,12 @@ instance RenderSQL (WindowDefinition commons schemas from grp params) where
20572072
20582073partitionBy
20592074 :: SListI bys
2060− => NP (Expression grp commons schemas params from) bys
2061− -> WindowDefinition grp commons schemas params from
2075+ => NP (Expression outer grp commons schemas params from) bys
2076+ -> WindowDefinition outer grp commons schemas params from
20622077partitionBy bys = WindowDefinition bys []
20632078
20642079newtype WindowFunction
2080+ (outer :: FromType)
20652081 (grp :: Grouping)
20662082 (commons :: FromType)
20672083 (schemas :: SchemasType)
@@ -2071,20 +2087,20 @@ newtype WindowFunction
20712087 = UnsafeWindowFunction { renderWindowFunction :: ByteString }
20722088 deriving (GHC.Generic,Show,Eq,Ord,NFData)
20732089
2074−instance RenderSQL (WindowFunction grp commons schemas params from ty) where
2090+instance RenderSQL (WindowFunction outer grp commons schemas params from ty) where
20752091 renderSQL = renderWindowFunction
20762092
20772093unsafeWindowFunction1
20782094 :: ByteString
2079− -> Expression grp commons schemas params from ty0
2080− -> WindowFunction grp commons schemas params from ty1
2095+ -> Expression outer grp commons schemas params from ty0
2096+ -> WindowFunction outer grp commons schemas params from ty1
20812097unsafeWindowFunction1 fun x
20822098 = UnsafeWindowFunction $ fun <> parenthesized (renderSQL x)
20832099
20842100unsafeWindowFunction2
20852101 :: ByteString
2086− -> (Expression grp commons schemas params from :*: Expression grp commons schemas params from) ty0
2087− -> WindowFunction grp commons schemas params from ty1
2102+ -> (Expression outer grp commons schemas params from :*: Expression outer grp commons schemas params from) ty0
2103+ -> WindowFunction outer grp commons schemas params from ty1
20882104unsafeWindowFunction2 fun (x :*: x')
20892105 = UnsafeWindowFunction $ fun <> parenthesized (renderSQL x <> ", " <> renderSQL x')
20902106
@@ -2092,28 +2108,28 @@ unsafeWindowFunction2 fun (x :*: x')
20922108>>> printSQL rank
20932109rank()
20942110-}
2095−rank :: WindowFunction grp commons schemas params from ('NotNull 'PGint8)
2111+rank :: WindowFunction outer grp commons schemas params from ('NotNull 'PGint8)
20962112rank = UnsafeWindowFunction "rank()"
20972113
20982114{- | number of the current row within its partition, counting from 1
20992115>>> printSQL rowNumber
21002116row_number()
21012117-}
2102−rowNumber :: WindowFunction grp commons schemas params from ('NotNull 'PGint8)
2118+rowNumber :: WindowFunction outer grp commons schemas params from ('NotNull 'PGint8)
21032119rowNumber = UnsafeWindowFunction "row_number()"
21042120
21052121{- | rank of the current row without gaps; this function counts peer groups
21062122>>> printSQL denseRank
21072123dense_rank()
21082124-}
2109−denseRank :: WindowFunction grp commons schemas params from ('NotNull 'PGint8)
2125+denseRank :: WindowFunction outer grp commons schemas params from ('NotNull 'PGint8)
21102126denseRank = UnsafeWindowFunction "dense_rank()"
21112127
21122128{- | relative rank of the current row: (rank - 1) / (total partition rows - 1)
21132129>>> printSQL percentRank
21142130percent_rank()
21152131-}
2116−percentRank :: WindowFunction grp commons schemas params from ('NotNull 'PGfloat8)
2132+percentRank :: WindowFunction outer grp commons schemas params from ('NotNull 'PGfloat8)
21172133percentRank = UnsafeWindowFunction "percent_rank()"
21182134
21192135{- | cumulative distribution: (number of partition rows
@@ -2121,16 +2137,16 @@ preceding or peer with current row) / total partition rows
21212137>>> printSQL cumeDist
21222138cume_dist()
21232139-}
2124−cumeDist :: WindowFunction grp commons schemas params from ('NotNull 'PGfloat8)
2140+cumeDist :: WindowFunction outer grp commons schemas params from ('NotNull 'PGfloat8)
21252141cumeDist = UnsafeWindowFunction "cume_dist()"
21262142
21272143{- | integer ranging from 1 to the argument value,
21282144dividing the partition as equally as possible
21292145-}
21302146ntile
2131− :: Expression grp commons schemas params from ('NotNull 'PGint4)
2147+ :: Expression outer grp commons schemas params from ('NotNull 'PGint4)
21322148 -- ^ num buckets
2133− -> WindowFunction grp commons schemas params from ('NotNull 'PGint4)
2149+ -> WindowFunction outer grp commons schemas params from ('NotNull 'PGint4)
21342150ntile = unsafeWindowFunction1 "ntile"
21352151
21362152{- | 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
21392155evaluated with respect to the current row.
21402156-}
21412157lag
2142− :: Expression grp commons schemas params from ty
2158+ :: Expression outer grp commons schemas params from ty
21432159 -- ^ value
2144− -> Expression grp commons schemas params from ('NotNull 'PGint4)
2160+ -> Expression outer grp commons schemas params from ('NotNull 'PGint4)
21452161 -- ^ offset
2146− -> Expression grp commons schemas params from ty
2162+ -> Expression outer grp commons schemas params from ty
21472163 -- ^ default
2148− -> WindowFunction grp commons schemas params from ty
2164+ -> WindowFunction outer grp commons schemas params from ty
21492165lag value offset def = UnsafeWindowFunction $ "lag"
21502166 <> parenthesized
21512167 (commaSeparated ([renderSQL value, renderSQL offset, renderSQL def]))
@@ -2156,13 +2172,13 @@ row within the partition; if there is no such row, instead return default
21562172evaluated with respect to the current row.
21572173-}
21582174lead
2159− :: Expression grp commons schemas params from ty
2175+ :: Expression outer grp commons schemas params from ty
21602176 -- ^ value
2161− -> Expression grp commons schemas params from ('NotNull 'PGint4)
2177+ -> Expression outer grp commons schemas params from ('NotNull 'PGint4)
21622178 -- ^ offset
2163− -> Expression grp commons schemas params from ty
2179+ -> Expression outer grp commons schemas params from ty
21642180 -- ^ default
2165− -> WindowFunction grp commons schemas params from ty
2181+ -> WindowFunction outer grp commons schemas params from ty
21662182lead value offset def = UnsafeWindowFunction $ "lag"
21672183 <> parenthesized
21682184 (commaSeparated ([renderSQL value, renderSQL offset, renderSQL def]))
@@ -2171,28 +2187,28 @@ lead value offset def = UnsafeWindowFunction $ "lag"
21712187first row of the window frame
21722188-}
21732189firstValue
2174− :: Expression grp commons schemas params from ty
2190+ :: Expression outer grp commons schemas params from ty
21752191 -- ^ value
2176− -> WindowFunction grp commons schemas params from ty
2192+ -> WindowFunction outer grp commons schemas params from ty
21772193firstValue = unsafeWindowFunction1 "first_value"
21782194
21792195{- | returns value evaluated at the row that is the
21802196last row of the window frame
21812197-}
21822198lastValue
2183− :: Expression grp commons schemas params from ty
2199+ :: Expression outer grp commons schemas params from ty
21842200 -- ^ value
2185− -> WindowFunction grp commons schemas params from ty
2201+ -> WindowFunction outer grp commons schemas params from ty
21862202lastValue = unsafeWindowFunction1 "last_value"
21872203
21882204{- | returns value evaluated at the row that is the nth
21892205row of the window frame (counting from 1); null if no such row
21902206-}
21912207nthValue
2192− :: Expression grp commons schemas params from (nullity ty)
2208+ :: Expression outer grp commons schemas params from (nullity ty)
21932209 -- ^ value
2194− -> Expression grp commons schemas params from ('NotNull 'PGint4)
2210+ -> Expression outer grp commons schemas params from ('NotNull 'PGint4)
21952211 -- ^ nth
2196− -> WindowFunction grp commons schemas params from ('Null ty)
2212+ -> WindowFunction outer grp commons schemas params from ('Null ty)
21972213nthValue value nth = UnsafeWindowFunction $ "nth_value"
21982214 <> parenthesized (commaSeparated [renderSQL value, renderSQL nth])
squeal-postgresql/src/Squeal/PostgreSQL/Manipulation.hs+19−18
@@ -173,9 +173,10 @@ type Schema3 =
173173let
174174 manipulation :: Manipulation '[] (Public Schema3) '[] '[]
175175 manipulation =
176− deleteFrom_ #tab (Using (table #other_tab & also (table #third_tab)))
176+ deleteFrom #tab (Using (table #other_tab & also (table #third_tab)))
177177 ( (#tab ! #col2 .== #other_tab ! #col2)
178178 .&& (#tab ! #col2 .== #third_tab ! #col2) )
179+ (Returning_ Nil)
179180in printSQL manipulation
180181:}
181182DELETE FROM "tab" USING "other_tab" AS "other_tab", "third_tab" AS "third_tab" WHERE (("tab"."col2" = "other_tab"."col2") AND ("tab"."col2" = "third_tab"."col2"))
@@ -214,7 +215,7 @@ type family Manipulation_ (schemas :: SchemasType) (params :: Type) (row :: Type
214215
215216-- | Convert a `Query` into a `Manipulation`.
216217queryStatement
217− :: Query commons schemas params columns
218+ :: Query '[] commons schemas params columns
218219 -> Manipulation commons schemas params columns
219220queryStatement q = UnsafeManipulation $ renderSQL q
220221
@@ -268,11 +269,11 @@ data QueryClause commons schemas params columns where
268269 Select
269270 :: SOP.SListI columns
270271 => NP (ColumnExpression grp schemas params from) columns
271− -> TableExpression grp commons schemas params from
272+ -> TableExpression '[] grp commons schemas params from
272273 -> QueryClause commons schemas params columns
273274 Subquery
274275 :: ColumnsToRow columns ~ row
275− => Query commons schemas params row
276+ => Query '[] commons schemas params row
276277 -> QueryClause commons schemas params columns
277278
278279instance RenderSQL (QueryClause commons schemas params columns) where
@@ -319,17 +320,17 @@ data ColumnExpression grp schemas params from column where
319320 => Alias col
320321 -> ColumnExpression grp schemas params from (col ::: 'Def :=> ty)
321322 Specific
322− :: Aliased (Expression grp '[] schemas params from) (col ::: ty)
323+ :: Aliased (Expression '[] grp '[] schemas params from) (col ::: ty)
323324 -> ColumnExpression grp schemas params from (col ::: defness :=> ty)
324325
325326instance (KnownSymbol col, column ~ (col ::: defness :=> ty))
326327 => Aliasable col
327− (Expression grp '[] schemas params from ty)
328+ (Expression '[] grp '[] schemas params from ty)
328329 (ColumnExpression grp schemas params from column) where
329330 expression `as` col = Specific (expression `As` col)
330331instance (KnownSymbol col, columns ~ '[col ::: defness :=> ty])
331332 => Aliasable col
332− (Expression grp '[] schemas params from ty)
333+ (Expression '[] grp '[] schemas params from ty)
333334 (NP (ColumnExpression grp schemas params from) columns) where
334335 expression `as` col = expression `as` col :* Nil
335336instance (KnownSymbol col, column ~ (col ::: 'Def :=> ty))
@@ -406,7 +407,7 @@ instance RenderSQL (ColumnExpression grp schemas params from column) where
406407-- in the row. Use @Returning Nil@ in the common case where no return
407408-- values are desired.
408409newtype ReturningClause commons schemas params from row =
409− Returning (Selection 'Ungrouped commons schemas params from row)
410+ Returning (Selection '[] 'Ungrouped commons schemas params from row)
410411
411412instance RenderSQL (ReturningClause commons schemas params from row) where
412413 renderSQL = \case
@@ -415,7 +416,7 @@ instance RenderSQL (ReturningClause commons schemas params from row) where
415416
416417pattern Returning_
417418 :: SOP.SListI row
418− => NP (Aliased (Expression 'Ungrouped commons schemas params from)) row
419+ => NP (Aliased (Expression '[] 'Ungrouped commons schemas params from)) row
419420 -> ReturningClause commons schemas params from row
420421pattern Returning_ list = Returning (List list)
421422
@@ -448,7 +449,7 @@ data ConflictAction tab commons schemas params columns where
448449 , SOP.All (HasIn columns) subcolumns
449450 , AllUnique subcolumns )
450451 => NP (ColumnExpression 'Ungrouped schemas params '[tab ::: row, "excluded" ::: row]) subcolumns
451− -> [Condition 'Ungrouped commons schemas params '[tab ::: row, "excluded" ::: row]]
452+ -> [Condition '[] 'Ungrouped commons schemas params '[tab ::: row, "excluded" ::: row]]
452453 -> ConflictAction tab commons schemas params columns
453454
454455instance RenderSQL (ConflictAction tab commons schemas params columns) where
@@ -493,7 +494,7 @@ update
493494 => QualifiedAlias sch tab -- ^ table to update
494495 -> NP (ColumnExpression 'Ungrouped schemas params '[tab ::: row0]) subcolumns
495496 -- ^ modified values to replace old values
496− -> Condition 'Ungrouped commons schemas params '[tab ::: row0]
497+ -> Condition '[] 'Ungrouped commons schemas params '[tab ::: row0]
497498 -- ^ condition under which to perform update on a row
498499 -> ReturningClause commons schemas params '[tab ::: row0] row1 -- ^ results to return
499500 -> Manipulation commons schemas params row1
@@ -518,7 +519,7 @@ update_
518519 => QualifiedAlias sch tab -- ^ table to update
519520 -> NP (ColumnExpression 'Ungrouped schemas params '[tab ::: row]) subcolumns
520521 -- ^ modified values to replace old values
521− -> Condition 'Ungrouped commons schemas params '[tab ::: row]
522+ -> Condition '[] 'Ungrouped commons schemas params '[tab ::: row]
522523 -- ^ condition under which to perform update on a row
523524 -> Manipulation commons schemas params '[]
524525update_ tab columns wh = update tab columns wh (Returning_ Nil)
@@ -530,7 +531,7 @@ DELETE statements
530531data UsingClause commons schemas params from where
531532 NoUsing :: UsingClause commons schemas params '[]
532533 Using
533− :: FromClause commons schemas params from
534+ :: FromClause '[] commons schemas params from
534535 -> UsingClause commons schemas params from
535536
536537-- | Delete rows from a table.
@@ -543,7 +544,7 @@ deleteFrom
543544 , columns ~ TableToColumns table )
544545 => QualifiedAlias sch tab -- ^ table to delete from
545546 -> UsingClause commons schemas params from
546− -> Condition 'Ungrouped commons schemas params (tab ::: row0 ': from)
547+ -> Condition '[] 'Ungrouped commons schemas params (tab ::: row0 ': from)
547548 -- ^ condition under which to delete a row
548549 -> ReturningClause commons schemas params '[tab ::: row0] row1 -- ^ results to return
549550 -> Manipulation commons schemas params row1
@@ -564,7 +565,7 @@ deleteFrom_
564565 , row ~ TableToRow table
565566 , columns ~ TableToColumns table )
566567 => QualifiedAlias sch tab -- ^ table to delete from
567− -> Condition 'Ungrouped commons schemas params '[tab ::: row]
568+ -> Condition '[] 'Ungrouped commons schemas params '[tab ::: row]
568569 -- ^ condition under which to delete a row
569570 -> Manipulation commons schemas params '[]
570571deleteFrom_ tab wh = deleteFrom tab NoUsing wh (Returning_ Nil)
@@ -575,10 +576,10 @@ deleteFrom_ tab wh = deleteFrom tab NoUsing wh (Returning_ Nil)
575576-- a comma separated list of tables. Typical case is the `USING` clause
576577-- of a DELETE query.
577578also
578− :: FromClause commons schemas params right
579+ :: FromClause outer commons schemas params right
579580 -- ^ right
580− -> FromClause commons schemas params left
581+ -> FromClause outer commons schemas params left
581582 -- ^ left
582− -> FromClause commons schemas params (Join left right)
583+ -> FromClause outer commons schemas params (Join left right)
583584also right left = UnsafeFromClause $
584585 renderSQL left <> "," <+> renderSQL right
squeal-postgresql/src/Squeal/PostgreSQL/Migration.hs+1−1
@@ -289,7 +289,7 @@ deleteMigration = deleteFrom_ (#migrations ! #schema_migrations) (#name .== para
289289-- the time at which it was executed.
290290selectMigration
291291 :: Has "migrations" schemas MigrationsSchema
292− => Query '[] schemas '[ 'NotNull 'PGtext ]
292+ => Query '[] '[] schemas '[ 'NotNull 'PGtext ]
293293 '[ "executed_at" ::: 'NotNull 'PGtimestamptz ]
294294selectMigration = select_
295295 (#executed_at `as` #executed_at)
squeal-postgresql/src/Squeal/PostgreSQL/PQ.hs+2−2
@@ -333,13 +333,13 @@ class Monad pq => MonadPQ schemas pq | pq -> schemas where
333333
334334 runQueryParams
335335 :: ToParams x params
336− => Query '[] schemas params ys
336+ => Query '[] '[] schemas params ys
337337 -- ^ `select` and friends
338338 -> x -> pq (K LibPQ.Result ys)
339339 runQueryParams = manipulateParams . queryStatement
340340
341341 runQuery
342− :: Query '[] schemas '[] ys
342+ :: Query '[] '[] schemas '[] ys
343343 -- ^ `select` and friends
344344 -> pq (K LibPQ.Result ys)
345345 runQuery q = runQueryParams q ()
squeal-postgresql/src/Squeal/PostgreSQL/Query.hs+290−459
@@ -91,32 +91,12 @@ module Squeal.PostgreSQL.Query
9191 , GroupByClause (..)
9292 , HavingClause (..)
9393 -- * Subquery Expressions
94+ , exists
9495 , in_
95− , rowIn
96− , eqAll
97− , rowEqAll
98− , eqAny
99− , rowEqAny
100− , neqAll
101− , rowNeqAll
102− , neqAny
103− , rowNeqAny
104− , allLt
105− , rowLtAll
106− , ltAny
107− , rowLtAny
108− , lteAll
109− , rowLteAll
110− , lteAny
111− , rowLteAny
112− , gtAll
113− , rowGtAll
114− , gtAny
115− , rowGtAny
116− , gteAll
117− , rowGteAll
118− , gteAny
119− , rowGteAny
96+ , notIn
97+ , Operator
98+ , subAll
99+ , subAny
120100 ) where
121101
122102import Control.DeepSeq
@@ -127,6 +107,7 @@ import Data.Word
127107import Generics.SOP hiding (from)
128108import GHC.TypeLits
129109
110+import qualified Data.ByteString as ByteString
130111import qualified GHC.Generics as GHC
131112
132113import Squeal.PostgreSQL.Expression
@@ -143,7 +124,7 @@ simple query:
143124>>> type Schema = '["tab" ::: 'Table ('[] :=> Columns)]
144125>>> :{
145126let
146− query :: Query '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
127+ query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
147128 query = select Star (from (table #tab))
148129in printSQL query
149130:}
@@ -153,7 +134,7 @@ restricted query:
153134
154135>>> :{
155136let
156− query :: Query '[] (Public Schema) '[] '["sum" ::: 'NotNull 'PGint4, "col1" ::: 'NotNull 'PGint4]
137+ query :: Query '[] '[] (Public Schema) '[] '["sum" ::: 'NotNull 'PGint4, "col1" ::: 'NotNull 'PGint4]
157138 query =
158139 select_ ((#col1 + #col2) `as` #sum :* #col1)
159140 ( from (table #tab)
@@ -167,7 +148,7 @@ subquery:
167148
168149>>> :{
169150let
170− query :: Query '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
151+ query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
171152 query = select Star (from (subquery (select Star (from (table #tab)) `as` #sub)))
172153in printSQL query
173154:}
@@ -177,7 +158,7 @@ limits and offsets:
177158
178159>>> :{
179160let
180− query :: Query '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
161+ query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
181162 query = select Star (from (table #tab) & limit 100 & offset 2 & limit 50 & offset 2)
182163in printSQL query
183164:}
@@ -187,7 +168,7 @@ parameterized query:
187168
188169>>> :{
189170let
190− query :: Query '[] (Public Schema) '[ 'NotNull 'PGint4] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
171+ query :: Query '[] '[] (Public Schema) '[ 'NotNull 'PGint4] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
191172 query = select Star (from (table #tab) & where_ (#col1 .> param @1))
192173in printSQL query
193174:}
@@ -197,7 +178,7 @@ aggregation query:
197178
198179>>> :{
199180let
200− query :: Query '[] (Public Schema) '[] '["sum" ::: 'NotNull 'PGint4, "col1" ::: 'NotNull 'PGint4 ]
181+ query :: Query '[] '[] (Public Schema) '[] '["sum" ::: 'NotNull 'PGint4, "col1" ::: 'NotNull 'PGint4 ]
201182 query =
202183 select_ (sum_ (All #col2) `as` #sum :* #col1)
203184 ( from (table (#tab `as` #table1))
@@ -211,7 +192,7 @@ sorted query:
211192
212193>>> :{
213194let
214− query :: Query '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
195+ query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
215196 query = select Star (from (table #tab) & orderBy [#col1 & Asc])
216197in printSQL query
217198:}
@@ -248,7 +229,7 @@ type OrdersSchema =
248229
249230>>> :{
250231let
251− query :: Query '[] (Public OrdersSchema)
232+ query :: Query '[] '[] (Public OrdersSchema)
252233 '[]
253234 '[ "order_price" ::: 'NotNull 'PGfloat4
254235 , "customer_name" ::: 'NotNull 'PGtext
@@ -271,7 +252,7 @@ self-join:
271252
272253>>> :{
273254let
274− query :: Query '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
255+ query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
275256 query = select (#t1 & DotStar) (from (table (#tab `as` #t1) & crossJoin (table (#tab `as` #t2))))
276257in printSQL query
277258:}
@@ -281,7 +262,7 @@ value queries:
281262
282263>>> :{
283264let
284− query :: Query commons schemas '[] '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
265+ query :: Query '[] commons schemas '[] '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
285266 query = values (1 `as` #foo :* true `as` #bar) [2 `as` #foo :* false `as` #bar]
286267in printSQL query
287268:}
@@ -291,7 +272,7 @@ set operations:
291272
292273>>> :{
293274let
294− query :: Query '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
275+ query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
295276 query = select Star (from (table #tab)) `unionAll` select Star (from (table #tab))
296277in printSQL query
297278:}
@@ -301,7 +282,7 @@ with queries:
301282
302283>>> :{
303284let
304− query :: Query '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
285+ query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4, "col2" ::: 'NotNull 'PGint4]
305286 query = with (
306287 select Star (from (table #tab)) `as` #cte1 :>>
307288 select Star (from (common #cte1)) `as` #cte2
@@ -314,32 +295,47 @@ window function queries
314295
315296>>> :{
316297let
317− query :: Query '[] (Public Schema) '[] ["col1" ::: 'NotNull 'PGint4, "rank" ::: 'NotNull 'PGint8]
298+ query :: Query '[] '[] (Public Schema) '[] ["col1" ::: 'NotNull 'PGint4, "rank" ::: 'NotNull 'PGint8]
318299 query = select
319300 (#col1 & Also (rank `as` #rank `Over` (partitionBy #col1 & orderBy [#col2 & Asc])))
320301 (from (table #tab))
321302in printSQL query
322303:}
323304SELECT "col1" AS "col1", rank() OVER (PARTITION BY "col1" ORDER BY "col2" ASC) AS "rank" FROM "tab" AS "tab"
305+
306+correlated subqueries
307+
308+>>> :{
309+let
310+ query :: Query '[] '[] (Public Schema) '[] '["col1" ::: 'NotNull 'PGint4]
311+ query =
312+ select #col1 (from (table (#tab `as` #t1))
313+ & where_ (exists (
314+ select Star (from (table (#tab `as` #t2))
315+ & where_ (#t2 ! #col2 .== #t1 ! #col1)))))
316+in printSQL query
317+:}
318+SELECT "col1" AS "col1" FROM "tab" AS "t1" WHERE EXISTS (SELECT * FROM "tab" AS "t2" WHERE ("t2"."col2" = "t1"."col1"))
324319-}
325320newtype Query
321+ (outer :: FromType)
326322 (commons :: FromType)
327323 (schemas :: SchemasType)
328324 (params :: [NullityType])
329325 (row :: RowType)
330326 = UnsafeQuery { renderQuery :: ByteString }
331327 deriving (GHC.Generic,Show,Eq,Ord,NFData)
332−instance RenderSQL (Query commons schemas params row) where renderSQL = renderQuery
328+instance RenderSQL (Query outer commons schemas params row) where renderSQL = renderQuery
333329
334330type family Query_ (schemas :: SchemasType) (params :: Type) (row :: Type) where
335− Query_ schemas params row = Query '[] schemas (TuplePG params) (RowPG row)
331+ Query_ schemas params row = Query '[] '[] schemas (TuplePG params) (RowPG row)
336332
337333-- | The results of two queries can be combined using the set operation
338334-- `union`. Duplicate rows are eliminated.
339335union
340− :: Query commons schemas params columns
341− -> Query commons schemas params columns
342− -> Query commons schemas params columns
336+ :: Query outer commons schemas params columns
337+ -> Query outer commons schemas params columns
338+ -> Query outer commons schemas params columns
343339q1 `union` q2 = UnsafeQuery $
344340 parenthesized (renderSQL q1)
345341 <+> "UNION"
@@ -348,9 +344,9 @@ q1 `union` q2 = UnsafeQuery $
348344-- | The results of two queries can be combined using the set operation
349345-- `unionAll`, the disjoint union. Duplicate rows are retained.
350346unionAll
351− :: Query commons schemas params columns
352− -> Query commons schemas params columns
353− -> Query commons schemas params columns
347+ :: Query outer commons schemas params columns
348+ -> Query outer commons schemas params columns
349+ -> Query outer commons schemas params columns
354350q1 `unionAll` q2 = UnsafeQuery $
355351 parenthesized (renderSQL q1)
356352 <+> "UNION" <+> "ALL"
@@ -359,9 +355,9 @@ q1 `unionAll` q2 = UnsafeQuery $
359355-- | The results of two queries can be combined using the set operation
360356-- `intersect`, the intersection. Duplicate rows are eliminated.
361357intersect
362− :: Query commons schemas params columns
363− -> Query commons schemas params columns
364− -> Query commons schemas params columns
358+ :: Query outer commons schemas params columns
359+ -> Query outer commons schemas params columns
360+ -> Query outer commons schemas params columns
365361q1 `intersect` q2 = UnsafeQuery $
366362 parenthesized (renderSQL q1)
367363 <+> "INTERSECT"
@@ -370,9 +366,9 @@ q1 `intersect` q2 = UnsafeQuery $
370366-- | The results of two queries can be combined using the set operation
371367-- `intersectAll`, the intersection. Duplicate rows are retained.
372368intersectAll
373− :: Query commons schemas params columns
374− -> Query commons schemas params columns
375− -> Query commons schemas params columns
369+ :: Query outer commons schemas params columns
370+ -> Query outer commons schemas params columns
371+ -> Query outer commons schemas params columns
376372q1 `intersectAll` q2 = UnsafeQuery $
377373 parenthesized (renderSQL q1)
378374 <+> "INTERSECT" <+> "ALL"
@@ -381,9 +377,9 @@ q1 `intersectAll` q2 = UnsafeQuery $
381377-- | The results of two queries can be combined using the set operation
382378-- `except`, the set difference. Duplicate rows are eliminated.
383379except
384− :: Query commons schemas params columns
385− -> Query commons schemas params columns
386− -> Query commons schemas params columns
380+ :: Query outer commons schemas params columns
381+ -> Query outer commons schemas params columns
382+ -> Query outer commons schemas params columns
387383q1 `except` q2 = UnsafeQuery $
388384 parenthesized (renderSQL q1)
389385 <+> "EXCEPT"
@@ -392,9 +388,9 @@ q1 `except` q2 = UnsafeQuery $
392388-- | The results of two queries can be combined using the set operation
393389-- `exceptAll`, the set difference. Duplicate rows are retained.
394390exceptAll
395− :: Query commons schemas params columns
396− -> Query commons schemas params columns
397− -> Query commons schemas params columns
391+ :: Query outer commons schemas params columns
392+ -> Query outer commons schemas params columns
393+ -> Query outer commons schemas params columns
398394q1 `exceptAll` q2 = UnsafeQuery $
399395 parenthesized (renderSQL q1)
400396 <+> "EXCEPT" <+> "ALL"
@@ -404,54 +400,58 @@ q1 `exceptAll` q2 = UnsafeQuery $
404400SELECT queries
405401-----------------------------------------}
406402
407−data Selection grp commons schemas params from row where
403+data Selection outer grp commons schemas params from row where
408404 List
409405 :: SListI row
410− => NP (Aliased (Expression grp commons schemas params from)) row
411− -> Selection grp commons schemas params from row
406+ => NP (Aliased (Expression outer grp commons schemas params from)) row
407+ -> Selection outer grp commons schemas params from row
412408 Star
413409 :: HasUnique tab from row
414− => Selection 'Ungrouped commons schemas params from row
410+ => Selection outer 'Ungrouped commons schemas params from row
415411 DotStar
416412 :: Has tab from row
417413 => Alias tab
418− -> Selection 'Ungrouped commons schemas params from row
414+ -> Selection outer 'Ungrouped commons schemas params from row
419415 Also
420− :: Selection grp commons schemas params from right
421− -> Selection grp commons schemas params from left
422− -> Selection grp commons schemas params from (Join left right)
416+ :: Selection outer grp commons schemas params from right
417+ -> Selection outer grp commons schemas params from left
418+ -> Selection outer grp commons schemas params from (Join left right)
423419 Over
424420 :: SListI row
425− => NP (Aliased (WindowFunction grp commons schemas params from)) row
426− -> WindowDefinition grp commons schemas params from
427− -> Selection grp commons schemas params from row
421+ => NP (Aliased (WindowFunction outer grp commons schemas params from)) row
422+ -> WindowDefinition outer grp commons schemas params from
423+ -> Selection outer grp commons schemas params from row
428424instance (KnownSymbol col, row ~ '[col ::: ty])
429425 => Aliasable col
430− (Expression grp commons schemas params from ty)
431− (Selection grp commons schemas params from row) where
426+ (Expression outer grp commons schemas params from ty)
427+ (Selection outer grp commons schemas params from row) where
432428 expr `as` col = List (expr `as` col)
433−instance (Has tab from row0, Has col row0 ty, row1 ~ '[col ::: ty])
434− => IsQualified tab col (Selection 'Ungrouped commons schemas params from row1) where
435− tab ! col = tab ! col `as` col
429+instance (Has tab (Join outer from) row0, Has col row0 ty, row1 ~ '[col ::: ty])
430+ => IsQualified tab col
431+ (Selection outer 'Ungrouped commons schemas params from row1) where
432+ tab ! col = tab ! col `as` col
436433instance
437− ( Has tab from row0
434+ ( Has tab (Join outer from) row0
438435 , Has col row0 ty
439436 , row1 ~ '[col ::: ty]
440437 , GroupedBy tab col bys )
441− => IsQualified tab col (Selection ('Grouped bys) commons schemas params from row1) where
442− tab ! col = tab ! col `as` col
443−instance (HasUnique tab from row0, Has col row0 ty, row1 ~ '[col ::: ty])
444− => IsLabel col (Selection 'Ungrouped commons schemas params from row1) where
445− fromLabel = fromLabel @col `as` Alias
438+ => IsQualified tab col
439+ (Selection outer ('Grouped bys) commons schemas params from row1) where
440+ tab ! col = tab ! col `as` col
441+instance (HasUnique tab (Join outer from) row0, Has col row0 ty, row1 ~ '[col ::: ty])
442+ => IsLabel col
443+ (Selection outer 'Ungrouped commons schemas params from row1) where
444+ fromLabel = fromLabel @col `as` Alias
446445instance
447− ( HasUnique tab from row0
446+ ( HasUnique tab (Join outer from) row0
448447 , Has col row0 ty
449448 , row1 ~ '[col ::: ty]
450449 , GroupedBy tab col bys )
451− => IsLabel col (Selection ('Grouped bys) commons schemas params from row1) where
452− fromLabel = fromLabel @col `as` Alias
450+ => IsLabel col
451+ (Selection outer ('Grouped bys) commons schemas params from row1) where
452+ fromLabel = fromLabel @col `as` Alias
453453
454−instance RenderSQL (Selection grp commons schemas params from row) where
454+instance RenderSQL (Selection outer grp commons schemas params from row) where
455455 renderSQL = \case
456456 List list -> renderCommaSeparated (renderAliased renderSQL) list
457457 Star -> "*"
@@ -460,7 +460,7 @@ instance RenderSQL (Selection grp commons schemas params from row) where
460460 Over winFns winDef ->
461461 let
462462 renderOver
463− :: Aliased (WindowFunction grp commons schemas params from) field
463+ :: Aliased (WindowFunction outer grp commons schemas params from) field
464464 -> ByteString
465465 renderOver (winFn `As` col) = renderSQL winFn
466466 <+> "OVER" <+> parenthesized (renderSQL winDef)
@@ -475,11 +475,11 @@ instance RenderSQL (Selection grp commons schemas params from row) where
475475-- the intermediate table are actually output.
476476select
477477 :: (SListI row, row ~ (x ': xs))
478− => Selection grp commons schemas params from row
478+ => Selection outer grp commons schemas params from row
479479 -- ^ select list
480− -> TableExpression grp commons schemas params from
480+ -> TableExpression outer grp commons schemas params from
481481 -- ^ intermediate virtual table
482− -> Query commons schemas params row
482+ -> Query outer commons schemas params row
483483select selection tabexpr = UnsafeQuery $
484484 "SELECT"
485485 <+> renderSQL selection
@@ -487,20 +487,20 @@ select selection tabexpr = UnsafeQuery $
487487
488488select_
489489 :: (SListI row, row ~ (x ': xs))
490− => NP (Aliased (Expression grp commons schemas params from)) row
491− -> TableExpression grp commons schemas params from
492− -> Query commons schemas params row
490+ => NP (Aliased (Expression outer grp commons schemas params from)) row
491+ -> TableExpression outer grp commons schemas params from
492+ -> Query outer commons schemas params row
493493select_ list = select (List list)
494494
495495-- | After the select list has been processed, the result table can
496496-- be subject to the elimination of duplicate rows using `selectDistinct`.
497497selectDistinct
498498 :: (SListI columns, columns ~ (col ': cols))
499− => Selection 'Ungrouped commons schemas params from columns
499+ => Selection outer 'Ungrouped commons schemas params from columns
500500 -- ^ select list
501− -> TableExpression 'Ungrouped commons schemas params from
501+ -> TableExpression outer 'Ungrouped commons schemas params from
502502 -- ^ intermediate virtual table
503− -> Query commons schemas params columns
503+ -> Query outer commons schemas params columns
504504selectDistinct selection tabexpr = UnsafeQuery $
505505 "SELECT DISTINCT"
506506 <+> renderSQL selection
@@ -508,11 +508,11 @@ selectDistinct selection tabexpr = UnsafeQuery $
508508
509509selectDistinct_
510510 :: (SListI columns, columns ~ (col ': cols))
511− => NP (Aliased (Expression 'Ungrouped commons schemas params from)) columns
511+ => NP (Aliased (Expression outer 'Ungrouped commons schemas params from)) columns
512512 -- ^ select list
513− -> TableExpression 'Ungrouped commons schemas params from
513+ -> TableExpression outer 'Ungrouped commons schemas params from
514514 -- ^ intermediate virtual table
515− -> Query commons schemas params columns
515+ -> Query outer commons schemas params columns
516516selectDistinct_ list = select (List list)
517517
518518-- | `values` computes a row value or set of row values
@@ -521,16 +521,16 @@ selectDistinct_ list = select (List list)
521521-- but it can be used on its own.
522522--
523523-- >>> type Row = '["a" ::: 'NotNull 'PGint4, "b" ::: 'NotNull 'PGtext]
524−-- >>> let query = values (1 `as` #a :* "one" `as` #b) [] :: Query commons schemas '[] Row
524+-- >>> let query = values (1 `as` #a :* "one" `as` #b) [] :: Query outer commons schemas '[] Row
525525-- >>> printSQL query
526526-- SELECT * FROM (VALUES (1, E'one')) AS t ("a", "b")
527527values
528528 :: SListI cols
529− => NP (Aliased (Expression 'Ungrouped commons schemas params '[] )) cols
530− -> [NP (Aliased (Expression 'Ungrouped commons schemas params '[] )) cols]
529+ => NP (Aliased (Expression outer 'Ungrouped commons schemas params '[] )) cols
530+ -> [NP (Aliased (Expression outer 'Ungrouped commons schemas params '[] )) cols]
531531 -- ^ When more than one row is specified, all the rows must
532532 -- must have the same number of elements
533− -> Query commons schemas params cols
533+ -> Query outer commons schemas params cols
534534values rw rws = UnsafeQuery $ "SELECT * FROM"
535535 <+> parenthesized (
536536 "VALUES"
@@ -541,7 +541,7 @@ values rw rws = UnsafeQuery $ "SELECT * FROM"
541541 <+> parenthesized (renderCommaSeparated renderAliasPart rw)
542542 where
543543 renderAliasPart, renderValuePart
544− :: Aliased (Expression 'Ungrouped commons schemas params '[] ) ty -> ByteString
544+ :: Aliased (Expression outer 'Ungrouped commons schemas params '[] ) ty -> ByteString
545545 renderAliasPart (_ `As` name) = renderSQL name
546546 renderValuePart (value `As` _) = renderSQL value
547547
@@ -549,9 +549,9 @@ values rw rws = UnsafeQuery $ "SELECT * FROM"
549549-- specified by value expressions.
550550values_
551551 :: SListI cols
552− => NP (Aliased (Expression 'Ungrouped commons schemas params '[] )) cols
552+ => NP (Aliased (Expression outer 'Ungrouped commons schemas params '[] )) cols
553553 -- ^ one row of values
554− -> Query commons schemas params cols
554+ -> Query outer commons schemas params cols
555555values_ rw = values rw []
556556
557557{-----------------------------------------
@@ -565,16 +565,17 @@ Table Expressions
565565-- to a table on disk, a so-called base table, but more complex expressions
566566-- can be used to modify or combine base tables in various ways.
567567data TableExpression
568+ (outer :: FromType)
568569 (grp :: Grouping)
569570 (commons :: FromType)
570571 (schemas :: SchemasType)
571572 (params :: [NullityType])
572573 (from :: FromType)
573574 = TableExpression
574− { fromClause :: FromClause commons schemas params from
575+ { fromClause :: FromClause outer commons schemas params from
575576 -- ^ A table reference that can be a table name, or a derived table such
576577 -- as a subquery, a @JOIN@ construct, or complex combinations of these.
577− , whereClause :: [Condition 'Ungrouped commons schemas params from]
578+ , whereClause :: [Condition outer 'Ungrouped commons schemas params from]
578579 -- ^ optional search coditions, combined with `.&&`. After the processing
579580 -- of the `fromClause` is done, each row of the derived virtual table
580581 -- is checked against the search condition. If the result of the
@@ -590,13 +591,13 @@ data TableExpression
590591 -- set of rows having common values into one group row that represents all
591592 -- rows in the group. This is done to eliminate redundancy in the output
592593 -- and/or compute aggregates that apply to these groups.
593− , havingClause :: HavingClause grp commons schemas params from
594+ , havingClause :: HavingClause outer grp commons schemas params from
594595 -- ^ If a table has been grouped using `groupBy`, but only certain groups
595596 -- are of interest, the `havingClause` can be used, much like a
596597 -- `whereClause`, to eliminate groups from the result. Expressions in the
597598 -- `havingClause` can refer both to grouped expressions and to ungrouped
598599 -- expressions (which necessarily involve an aggregate function).
599− , orderByClause :: [SortExpression grp commons schemas params from]
600+ , orderByClause :: [SortExpression outer grp commons schemas params from]
600601 -- ^ The `orderByClause` is for optional sorting. When more than one
601602 -- `SortExpression` is specified, the later (right) values are used to sort
602603 -- rows that are equal according to the earlier (left) values.
@@ -613,7 +614,7 @@ data TableExpression
613614 }
614615
615616-- | Render a `TableExpression`
616−instance RenderSQL (TableExpression grp commons schemas params from) where
617+instance RenderSQL (TableExpression outer grp commons schemas params from) where
617618 renderSQL
618619 (TableExpression frm' whs' grps' hvs' srts' lims' offs') = mconcat
619620 [ "FROM ", renderSQL frm'
@@ -622,8 +623,7 @@ instance RenderSQL (TableExpression grp commons schemas params from) where
622623 , renderSQL hvs'
623624 , renderOrderByClause srts'
624625 , renderLimits lims'
625− , renderOffsets offs'
626− ]
626+ , renderOffsets offs' ]
627627 where
628628 renderWheres = \case
629629 [] -> ""
@@ -646,16 +646,16 @@ instance RenderSQL (TableExpression grp commons schemas params from) where
646646-- `group`, `having`, `orderBy`, `limit` and `offset`, using the `&` operator
647647-- to match the left-to-right sequencing of their placement in SQL.
648648from
649− :: FromClause commons schemas params from -- ^ table reference
650− -> TableExpression 'Ungrouped commons schemas params from
651−from rels = TableExpression rels [] NoGroups NoHaving [] [] []
649+ :: FromClause outer commons schemas params from -- ^ table reference
650+ -> TableExpression outer 'Ungrouped commons schemas params from
651+from tab = TableExpression tab [] NoGroups NoHaving [] [] []
652652
653653-- | A `where_` is an endomorphism of `TableExpression`s which adds a
654654-- search condition to the `whereClause`.
655655where_
656− :: Condition 'Ungrouped commons schemas params from -- ^ filtering condition
657− -> TableExpression grp commons schemas params from
658− -> TableExpression grp commons schemas params from
656+ :: Condition outer 'Ungrouped commons schemas params from -- ^ filtering condition
657+ -> TableExpression outer grp commons schemas params from
658+ -> TableExpression outer grp commons schemas params from
659659where_ wh rels = rels {whereClause = wh : whereClause rels}
660660
661661-- | A `groupBy` is a transformation of `TableExpression`s which switches
@@ -664,8 +664,8 @@ where_ wh rels = rels {whereClause = wh : whereClause rels}
664664groupBy
665665 :: SListI bys
666666 => NP (By from) bys -- ^ grouped columns
667− -> TableExpression 'Ungrouped commons schemas params from
668− -> TableExpression ('Grouped bys) commons schemas params from
667+ -> TableExpression outer 'Ungrouped commons schemas params from
668+ -> TableExpression outer ('Grouped bys) commons schemas params from
669669groupBy bys rels = TableExpression
670670 { fromClause = fromClause rels
671671 , whereClause = whereClause rels
@@ -679,9 +679,9 @@ groupBy bys rels = TableExpression
679679-- | A `having` is an endomorphism of `TableExpression`s which adds a
680680-- search condition to the `havingClause`.
681681having
682− :: Condition ('Grouped bys) commons schemas params from -- ^ having condition
683− -> TableExpression ('Grouped bys) commons schemas params from
684− -> TableExpression ('Grouped bys) commons schemas params from
682+ :: Condition outer ('Grouped bys) commons schemas params from -- ^ having condition
683+ -> TableExpression outer ('Grouped bys) commons schemas params from
684+ -> TableExpression outer ('Grouped bys) commons schemas params from
685685having hv rels = rels
686686 { havingClause = case havingClause rels of Having hvs -> Having (hv:hvs) }
687687
@@ -692,16 +692,16 @@ instance OrderBy TableExpression where
692692-- `limitClause`.
693693limit
694694 :: Word64 -- ^ limit parameter
695− -> TableExpression grp commons schemas params from
696− -> TableExpression grp commons schemas params from
695+ -> TableExpression outer grp commons schemas params from
696+ -> TableExpression outer grp commons schemas params from
697697limit lim rels = rels {limitClause = lim : limitClause rels}
698698
699699-- | An `offset` is an endomorphism of `TableExpression`s which adds to the
700700-- `offsetClause`.
701701offset
702702 :: Word64 -- ^ offset parameter
703− -> TableExpression grp commons schemas params from
704− -> TableExpression grp commons schemas params from
703+ -> TableExpression outer grp commons schemas params from
704+ -> TableExpression outer grp commons schemas params from
705705offset off rels = rels {offsetClause = off : offsetClause rels}
706706
707707{-----------------------------------------
@@ -710,56 +710,56 @@ JSON stuff
710710
711711unsafeSetOfFunction
712712 :: ByteString
713− -> Expression 'Ungrouped commons schemas params '[] ty
714− -> Query commons schemas params row
713+ -> Expression outer 'Ungrouped commons schemas params '[] ty
714+ -> Query outer commons schemas params row
715715unsafeSetOfFunction fun expr = UnsafeQuery $
716716 "SELECT * FROM " <> fun <> "(" <> renderSQL expr <> ")"
717717
718718-- | Expands the outermost JSON object into a set of key/value pairs.
719719jsonEach
720− :: Expression 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
721− -> Query commons schemas params
720+ :: Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
721+ -> Query outer commons schemas params
722722 '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGjson]
723723jsonEach = unsafeSetOfFunction "json_each"
724724
725725-- | Expands the outermost binary JSON object into a set of key/value pairs.
726726jsonbEach
727− :: Expression 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
728− -> Query commons schemas params
727+ :: Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
728+ -> Query outer commons schemas params
729729 '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGjsonb]
730730jsonbEach = unsafeSetOfFunction "jsonb_each"
731731
732732-- | Expands the outermost JSON object into a set of key/value pairs.
733733jsonEachAsText
734− :: Expression 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
735− -> Query commons schemas params
734+ :: Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
735+ -> Query outer commons schemas params
736736 '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGtext]
737737jsonEachAsText = unsafeSetOfFunction "json_each_text"
738738
739739-- | Expands the outermost binary JSON object into a set of key/value pairs.
740740jsonbEachAsText
741− :: Expression 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
742− -> Query commons schemas params
741+ :: Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
742+ -> Query outer commons schemas params
743743 '["key" ::: 'NotNull 'PGtext, "value" ::: 'NotNull 'PGtext]
744744jsonbEachAsText = unsafeSetOfFunction "jsonb_each_text"
745745
746746-- | Returns set of keys in the outermost JSON object.
747747jsonObjectKeys
748− :: Expression 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
749− -> Query commons schemas params '["json_object_keys" ::: 'NotNull 'PGtext]
748+ :: Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
749+ -> Query outer commons schemas params '["json_object_keys" ::: 'NotNull 'PGtext]
750750jsonObjectKeys = unsafeSetOfFunction "json_object_keys"
751751
752752-- | Returns set of keys in the outermost JSON object.
753753jsonbObjectKeys
754− :: Expression 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
755− -> Query commons schemas params '["jsonb_object_keys" ::: 'NotNull 'PGtext]
754+ :: Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
755+ -> Query outer commons schemas params '["jsonb_object_keys" ::: 'NotNull 'PGtext]
756756jsonbObjectKeys = unsafeSetOfFunction "jsonb_object_keys"
757757
758758unsafePopulateFunction
759759 :: ByteString
760760 -> TypeExpression schemas (nullity ('PGcomposite row))
761− -> Expression 'Ungrouped commons schemas params '[] ty
762− -> Query commons schemas params row
761+ -> Expression outer 'Ungrouped commons schemas params '[] ty
762+ -> Query outer commons schemas params row
763763unsafePopulateFunction fun ty expr = UnsafeQuery $
764764 "SELECT * FROM " <> fun <> "("
765765 <> "null::" <> renderSQL ty <> ", "
@@ -769,24 +769,24 @@ unsafePopulateFunction fun ty expr = UnsafeQuery $
769769-- type defined by the given table.
770770jsonPopulateRecord
771771 :: TypeExpression schemas (nullity ('PGcomposite row)) -- ^ row type
772− -> Expression 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
773− -> Query commons schemas params row
772+ -> Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
773+ -> Query outer commons schemas params row
774774jsonPopulateRecord = unsafePopulateFunction "json_populate_record"
775775
776776-- | Expands the binary JSON expression to a row whose columns match the record
777777-- type defined by the given table.
778778jsonbPopulateRecord
779779 :: TypeExpression schemas (nullity ('PGcomposite row)) -- ^ row type
780− -> Expression 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
781− -> Query commons schemas params row
780+ -> Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
781+ -> Query outer commons schemas params row
782782jsonbPopulateRecord = unsafePopulateFunction "jsonb_populate_record"
783783
784784-- | Expands the outermost array of objects in the given JSON expression to a
785785-- set of rows whose columns match the record type defined by the given table.
786786jsonPopulateRecordSet
787787 :: TypeExpression schemas (nullity ('PGcomposite row)) -- ^ row type
788− -> Expression 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json array
789− -> Query commons schemas params row
788+ -> Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json array
789+ -> Query outer commons schemas params row
790790jsonPopulateRecordSet = unsafePopulateFunction "json_populate_record_set"
791791
792792-- | Expands the outermost array of objects in the given binary JSON expression
@@ -794,16 +794,16 @@ jsonPopulateRecordSet = unsafePopulateFunction "json_populate_record_set"
794794-- table.
795795jsonbPopulateRecordSet
796796 :: TypeExpression schemas (nullity ('PGcomposite row)) -- ^ row type
797− -> Expression 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb array
798− -> Query commons schemas params row
797+ -> Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb array
798+ -> Query outer commons schemas params row
799799jsonbPopulateRecordSet = unsafePopulateFunction "jsonb_populate_record_set"
800800
801801unsafeRecordFunction
802802 :: (SListI record, json `In` PGJsonType)
803803 => ByteString
804− -> Expression 'Ungrouped commons schemas params '[] (nullity json)
804+ -> Expression outer 'Ungrouped commons schemas params '[] (nullity json)
805805 -> NP (Aliased (TypeExpression schemas)) record
806− -> Query commons schemas params record
806+ -> Query outer commons schemas params record
807807unsafeRecordFunction fun expr types = UnsafeQuery $
808808 "SELECT * FROM " <> fun <> "("
809809 <> renderSQL expr <> ")"
@@ -816,33 +816,33 @@ unsafeRecordFunction fun expr types = UnsafeQuery $
816816-- | Builds an arbitrary record from a JSON object.
817817jsonToRecord
818818 :: SListI record
819− => Expression 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
819+ => Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json object
820820 -> NP (Aliased (TypeExpression schemas)) record -- ^ record types
821− -> Query commons schemas params record
821+ -> Query outer commons schemas params record
822822jsonToRecord = unsafeRecordFunction "json_to_record"
823823
824824-- | Builds an arbitrary record from a binary JSON object.
825825jsonbToRecord
826826 :: SListI record
827− => Expression 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
827+ => Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb object
828828 -> NP (Aliased (TypeExpression schemas)) record -- ^ record types
829− -> Query commons schemas params record
829+ -> Query outer commons schemas params record
830830jsonbToRecord = unsafeRecordFunction "jsonb_to_record"
831831
832832-- | Builds an arbitrary set of records from a JSON array of objects.
833833jsonToRecordSet
834834 :: SListI record
835− => Expression 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json array
835+ => Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjson) -- ^ json array
836836 -> NP (Aliased (TypeExpression schemas)) record -- ^ record types
837− -> Query commons schemas params record
837+ -> Query outer commons schemas params record
838838jsonToRecordSet = unsafeRecordFunction "json_to_record_set"
839839
840840-- | Builds an arbitrary set of records from a binary JSON array of objects.
841841jsonbToRecordSet
842842 :: SListI record
843− => Expression 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb array
843+ => Expression outer 'Ungrouped commons schemas params '[] (nullity 'PGjsonb) -- ^ jsonb array
844844 -> NP (Aliased (TypeExpression schemas)) record -- ^ record types
845− -> Query commons schemas params record
845+ -> Query outer commons schemas params record
846846jsonbToRecordSet = unsafeRecordFunction "jsonb_to_record_set"
847847
848848{-----------------------------------------
@@ -853,38 +853,38 @@ FROM clauses
853853A `FromClause` can be a table name, or a derived table such
854854as a subquery, a @JOIN@ construct, or complex combinations of these.
855855-}
856−newtype FromClause commons schemas params from
856+newtype FromClause outer commons schemas params from
857857 = UnsafeFromClause { renderFromClause :: ByteString }
858858 deriving (GHC.Generic,Show,Eq,Ord,NFData)
859−instance RenderSQL (FromClause commons schemas params from) where
859+instance RenderSQL (FromClause outer commons schemas params from) where
860860 renderSQL = renderFromClause
861861
862862-- | A real `table` is a table from the database.
863863table
864864 :: (Has sch schemas schema, Has tab schema ('Table table))
865865 => Aliased (QualifiedAlias sch) (alias ::: tab)
866− -> FromClause commons schemas params '[alias ::: TableToRow table]
866+ -> FromClause outer commons schemas params '[alias ::: TableToRow table]
867867table (tab `As` alias) = UnsafeFromClause $
868868 renderSQL tab <+> "AS" <+> renderSQL alias
869869
870870-- | `subquery` derives a table from a `Query`.
871871subquery
872− :: Aliased (Query commons schemas params) query
873− -> FromClause commons schemas params '[query]
872+ :: Aliased (Query outer commons schemas params) query
873+ -> FromClause outer commons schemas params '[query]
874874subquery = UnsafeFromClause . renderAliased (parenthesized . renderQuery)
875875
876876-- | `view` derives a table from a `View`.
877877view
878878 :: (Has sch schemas schema, Has vw schema ('View view))
879879 => Aliased (QualifiedAlias sch) (alias ::: vw)
880− -> FromClause commons schemas params '[alias ::: view]
880+ -> FromClause outer commons schemas params '[alias ::: view]
881881view (vw `As` alias) = UnsafeFromClause $
882882 renderSQL vw <+> "AS" <+> renderSQL alias
883883
884884common
885885 :: Has cte commons common
886886 => Aliased Alias (alias ::: cte)
887− -> FromClause commons schemas params '[alias ::: common]
887+ -> FromClause outer commons schemas params '[alias ::: common]
888888common (cte `As` alias) = UnsafeFromClause $
889889 renderSQL cte <+> "AS" <+> renderSQL alias
890890
@@ -895,11 +895,11 @@ common (cte `As` alias) = UnsafeFromClause $
895895 have @n * m@ rows.
896896-}
897897crossJoin
898− :: FromClause commons schemas params right
898+ :: FromClause outer commons schemas params right
899899 -- ^ right
900− -> FromClause commons schemas params left
900+ -> FromClause outer commons schemas params left
901901 -- ^ left
902− -> FromClause commons schemas params (Join left right)
902+ -> FromClause outer commons schemas params (Join left right)
903903crossJoin right left = UnsafeFromClause $
904904 renderSQL left <+> "CROSS JOIN" <+> renderSQL right
905905
@@ -907,13 +907,13 @@ crossJoin right left = UnsafeFromClause $
907907the @on@ condition.
908908-}
909909innerJoin
910− :: FromClause commons schemas params right
910+ :: FromClause outer commons schemas params right
911911 -- ^ right
912− -> Condition 'Ungrouped commons schemas params (Join left right)
912+ -> Condition outer 'Ungrouped commons schemas params (Join left right)
913913 -- ^ @on@ condition
914− -> FromClause commons schemas params left
914+ -> FromClause outer commons schemas params left
915915 -- ^ left
916− -> FromClause commons schemas params (Join left right)
916+ -> FromClause outer commons schemas params (Join left right)
917917innerJoin right on left = UnsafeFromClause $
918918 renderSQL left <+> "INNER JOIN" <+> renderSQL right
919919 <+> "ON" <+> renderSQL on
@@ -924,13 +924,13 @@ innerJoin right on left = UnsafeFromClause $
924924 Thus, the joined table always has at least one row for each row in @left@.
925925-}
926926leftOuterJoin
927− :: FromClause commons schemas params right
927+ :: FromClause outer commons schemas params right
928928 -- ^ right
929− -> Condition 'Ungrouped commons schemas params (Join left right)
929+ -> Condition outer 'Ungrouped commons schemas params (Join left right)
930930 -- ^ @on@ condition
931− -> FromClause commons schemas params left
931+ -> FromClause outer commons schemas params left
932932 -- ^ left
933− -> FromClause commons schemas params (Join left (NullifyFrom right))
933+ -> FromClause outer commons schemas params (Join left (NullifyFrom right))
934934leftOuterJoin right on left = UnsafeFromClause $
935935 renderSQL left <+> "LEFT OUTER JOIN" <+> renderSQL right
936936 <+> "ON" <+> renderSQL on
@@ -942,13 +942,13 @@ leftOuterJoin right on left = UnsafeFromClause $
942942 have a row for each row in @right@.
943943-}
944944rightOuterJoin
945− :: FromClause commons schemas params right
945+ :: FromClause outer commons schemas params right
946946 -- ^ right
947− -> Condition 'Ungrouped commons schemas params (Join left right)
947+ -> Condition outer 'Ungrouped commons schemas params (Join left right)
948948 -- ^ @on@ condition
949− -> FromClause commons schemas params left
949+ -> FromClause outer commons schemas params left
950950 -- ^ left
951− -> FromClause commons schemas params (Join (NullifyFrom left) right)
951+ -> FromClause outer commons schemas params (Join (NullifyFrom left) right)
952952rightOuterJoin right on left = UnsafeFromClause $
953953 renderSQL left <+> "RIGHT OUTER JOIN" <+> renderSQL right
954954 <+> "ON" <+> renderSQL on
@@ -961,13 +961,13 @@ rightOuterJoin right on left = UnsafeFromClause $
961961 is added.
962962-}
963963fullOuterJoin
964− :: FromClause commons schemas params right
964+ :: FromClause outer commons schemas params right
965965 -- ^ right
966− -> Condition 'Ungrouped commons schemas params (Join left right)
966+ -> Condition outer 'Ungrouped commons schemas params (Join left right)
967967 -- ^ @on@ condition
968− -> FromClause commons schemas params left
968+ -> FromClause outer commons schemas params left
969969 -- ^ left
970− -> FromClause commons schemas params
970+ -> FromClause outer commons schemas params
971971 (Join (NullifyFrom left) (NullifyFrom right))
972972fullOuterJoin right on left = UnsafeFromClause $
973973 renderSQL left <+> "FULL OUTER JOIN" <+> renderSQL right
@@ -1036,290 +1036,121 @@ instance RenderSQL (GroupByClause grp from) where
10361036-- An `Ungrouped` `TableExpression` may only use `NoHaving` while a `Grouped`
10371037-- `TableExpression` must use `Having` whose conditions are combined with
10381038-- `.&&`.
1039−data HavingClause grp commons schemas params from where
1040− NoHaving :: HavingClause 'Ungrouped commons schemas params from
1039+data HavingClause outer grp commons schemas params from where
1040+ NoHaving :: HavingClause outer 'Ungrouped commons schemas params from
10411041 Having
1042− :: [Condition ('Grouped bys) commons schemas params from]
1043− -> HavingClause ('Grouped bys) commons schemas params from
1044−deriving instance Show (HavingClause grp commons schemas params from)
1045−deriving instance Eq (HavingClause grp commons schemas params from)
1046−deriving instance Ord (HavingClause grp commons schemas params from)
1042+ :: [Condition outer ('Grouped bys) commons schemas params from]
1043+ -> HavingClause outer ('Grouped bys) commons schemas params from
1044+deriving instance Show (HavingClause outer grp commons schemas params from)
1045+deriving instance Eq (HavingClause outer grp commons schemas params from)
1046+deriving instance Ord (HavingClause outer grp commons schemas params from)
10471047
10481048-- | Render a `HavingClause`.
1049−instance RenderSQL (HavingClause grp commons schemas params from) where
1049+instance RenderSQL (HavingClause outer grp commons schemas params from) where
10501050 renderSQL = \case
10511051 NoHaving -> ""
10521052 Having [] -> ""
10531053 Having conditions ->
10541054 " HAVING" <+> commaSeparated (renderSQL <$> conditions)
10551055
1056−unsafeSubqueryExpression
1057− :: ByteString
1058− -> Expression grp commons schemas params from ty
1059− -> Query commons schemas params '[alias ::: ty]
1060− -> Expression grp commons schemas params from (nullity 'PGbool)
1061−unsafeSubqueryExpression op x q = UnsafeExpression $
1062− renderSQL x <+> op <+> parenthesized (renderSQL q)
1063−
1064−unsafeRowSubqueryExpression
1065− :: SListI row
1066− => ByteString
1067− -> NP (Aliased (Expression grp commons schemas params from)) row
1068− -> Query commons schemas params row
1069− -> Expression grp commons schemas params from (nullity 'PGbool)
1070−unsafeRowSubqueryExpression op xs q = UnsafeExpression $
1071− renderSQL (row xs) <+> op <+> parenthesized (renderSQL q)
1072−
1073−-- | The right-hand side is a sub`Query`, which must return exactly one column.
1074−-- The left-hand expression is evaluated and compared to each row of the
1075−-- sub`Query` result. The result of `in_` is `true` if any equal subquery row is found.
1076−-- The result is `false` if no equal row is found
1077−-- (including the case where the subquery returns no rows).
1078−--
1079−-- >>> printSQL $ true `in_` values_ (true `as` #foo)
1080−-- TRUE IN (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1081−in_
1082− :: Expression grp commons schemas params from ty -- ^ expression
1083− -> Query commons schemas params '[alias ::: ty] -- ^ subquery
1084− -> Expression grp commons schemas params from (nullity 'PGbool)
1085−in_ = unsafeSubqueryExpression "IN"
1086−
1087−{- | The left-hand side of this form of `rowIn` is a row constructor.
1088−The right-hand side is a sub`Query`,
1089−which must return exactly as many columns as
1090−there are expressions in the left-hand row.
1091−The left-hand expressions are evaluated and compared row-wise to each row
1092−of the subquery result. The result of `rowIn`
1093−is `true` if any equal subquery row is found.
1094−The result is `false` if no equal row is found
1056+{-
1057+The argument of `exists` is an arbitrary subquery. The subquery is evaluated
1058+to determine whether it returns any rows. If it returns at least one row,
1059+the result of `exists` is `true`; if the subquery returns no rows,
1060+the result of `exists` is `false`.
1061+
1062+The subquery can refer to variables from the surrounding query,
1063+which will act as constants during any one evaluation of the subquery.
1064+
1065+The subquery will generally only be executed long enough to determine whether
1066+at least one row is returned, not all the way to completion.
1067+-}
1068+exists
1069+ :: Query (Join outer from) commons schemas params row
1070+ -> Condition outer grp commons schemas params from
1071+exists query = UnsafeExpression $ "EXISTS" <+> parenthesized (renderSQL query)
1072+
1073+type Operator ty1 ty2 ty3
1074+ = forall outer grp commons schemas params from
1075+ . Expression outer grp commons schemas params from ty1
1076+ -> Expression outer grp commons schemas params from ty2
1077+ -> Expression outer grp commons schemas params from ty3
1078+
1079+{- |
1080+The right-hand side is a parenthesized subquery, which must return
1081+exactly one column. The left-hand expression is evaluated and compared to each
1082+row of the subquery result using the given `Operator`,
1083+which must yield a Boolean result. The result of `subAll` is `true`
1084+if all rows yield true (including the case where the subquery returns no rows).
1085+The result is `false` if any `false` result is found.
1086+The result is `null_` if no comparison with a subquery row returns `false`,
1087+and at least one comparison returns `null_`.
1088+
1089+>>> printSQL $ subAll true (.==) (values_ (true `as` #foo))
1090+TRUE = ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1091+-}
1092+subAll
1093+ :: Expression outer grp commons schemas params from ty1 -- ^ expression
1094+ -> Operator ty1 ty2 ('Null 'PGbool) -- ^ operator
1095+ -> Query (Join outer from) commons schemas params '[col ::: ty2] -- ^ subquery
1096+ -> Condition outer grp commons schemas params from
1097+subAll expr (?) qry = UnsafeExpression $
1098+ renderSQL expr <> op <> "ALL" <+> parenthesized (renderSQL qry)
1099+ where
1100+ nil = UnsafeExpression ""
1101+ op = ByteString.init
1102+ . ByteString.tail
1103+ . renderSQL
1104+ $ nil ? nil
1105+
1106+{- |
1107+The right-hand side is a parenthesized subquery, which must return exactly one column.
1108+The left-hand expression is evaluated and compared to each row of the subquery result
1109+using the given `Operator`, which must yield a Boolean result. The result of `subAny` is `true`
1110+if any `true` result is obtained. The result is `false` if no true result is found
10951111(including the case where the subquery returns no rows).
10961112
1097−>>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1098−>>> printSQL $ myRow `rowIn` values_ myRow
1099−ROW(1, FALSE) IN (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1113+>>> printSQL $ subAll "foo" like (values_ ("foobar" `as` #foo))
1114+E'foo' LIKE ALL (SELECT * FROM (VALUES (E'foobar')) AS t ("foo"))
1115+-}
1116+subAny
1117+ :: Expression outer grp commons schemas params from ty1 -- ^ expression
1118+ -> Operator ty1 ty2 ('Null 'PGbool) -- ^ operator
1119+ -> Query (Join outer from) commons schemas params '[col ::: ty2] -- ^ subquery
1120+ -> Condition outer grp commons schemas params from
1121+subAny expr (?) qry = UnsafeExpression $
1122+ renderSQL expr <+> renderSQL (nil ? nil) <+> "ANY"
1123+ <+> parenthesized (renderSQL qry)
1124+ where
1125+ nil = UnsafeExpression ""
1126+
1127+{-
1128+The result is `true` if the left-hand expression's result is equal
1129+to any of the right-hand expressions.
1130+
1131+>>> printSQL $ true `in_` [true, false, null_]
1132+TRUE IN (TRUE, FALSE, NULL)
1133+-}
1134+in_
1135+ :: Expression outer grp commons schemas params from ty -- ^ expression
1136+ -> [Expression outer grp commons schemas params from ty]
1137+ -> Condition outer grp commons schemas params from
1138+expr `in_` exprs = UnsafeExpression $ renderSQL expr <+> "IN"
1139+ <+> parenthesized (commaSeparated (renderSQL <$> exprs))
1140+
1141+{-
1142+The result is `true` if the left-hand expression's result is not equal
1143+to any of the right-hand expressions.
1144+
1145+>>> printSQL $ true `notIn` [false, null_]
1146+TRUE NOT IN (FALSE, NULL)
11001147-}
1101−rowIn
1102− :: SListI row
1103− => NP (Aliased (Expression grp commons schemas params from)) row -- ^ row constructor
1104− -> Query commons schemas params row -- ^ subquery
1105− -> Expression grp commons schemas params from (nullity 'PGbool)
1106−rowIn = unsafeRowSubqueryExpression "IN"
1107−
1108−-- | >>> printSQL $ true `eqAll` values_ (true `as` #foo)
1109−-- TRUE = ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1110−eqAll
1111− :: Expression grp commons schemas params from ty -- ^ expression
1112− -> Query commons schemas params '[alias ::: ty] -- ^ subquery
1113− -> Expression grp commons schemas params from (nullity 'PGbool)
1114−eqAll = unsafeSubqueryExpression "= ALL"
1115−
1116−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1117−-- >>> printSQL $ myRow `rowEqAll` values_ myRow
1118−-- ROW(1, FALSE) = ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1119−rowEqAll
1120− :: SListI row
1121− => NP (Aliased (Expression grp commons schemas params from)) row -- ^ row constructor
1122− -> Query commons schemas params row -- ^ subquery
1123− -> Expression grp commons schemas params from (nullity 'PGbool)
1124−rowEqAll = unsafeRowSubqueryExpression "= ALL"
1125−
1126−-- | >>> printSQL $ true `eqAny` values_ (true `as` #foo)
1127−-- TRUE = ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1128−eqAny
1129− :: Expression grp commons schemas params from ty -- ^ expression
1130− -> Query commons schemas params '[alias ::: ty] -- ^ subquery
1131− -> Expression grp commons schemas params from (nullity 'PGbool)
1132−eqAny = unsafeSubqueryExpression "= ANY"
1133−
1134−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1135−-- >>> printSQL $ myRow `rowEqAny` values_ myRow
1136−-- ROW(1, FALSE) = ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1137−rowEqAny
1138− :: SListI row
1139− => NP (Aliased (Expression grp commons schemas params from)) row -- ^ row constructor
1140− -> Query commons schemas params row -- ^ subquery
1141− -> Expression grp commons schemas params from (nullity 'PGbool)
1142−rowEqAny = unsafeRowSubqueryExpression "= ANY"
1143−
1144−-- | >>> printSQL $ true `neqAll` values_ (true `as` #foo)
1145−-- TRUE <> ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1146−neqAll
1147− :: Expression grp commons schemas params from ty -- ^ expression
1148− -> Query commons schemas params '[alias ::: ty] -- ^ subquery
1149− -> Expression grp commons schemas params from (nullity 'PGbool)
1150−neqAll = unsafeSubqueryExpression "<> ALL"
1151−
1152−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1153−-- >>> printSQL $ myRow `rowNeqAll` values_ myRow
1154−-- ROW(1, FALSE) <> ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1155−rowNeqAll
1156− :: SListI row
1157− => NP (Aliased (Expression grp commons schemas params from)) row -- ^ row constructor
1158− -> Query commons schemas params row -- ^ subquery
1159− -> Expression grp commons schemas params from (nullity 'PGbool)
1160−rowNeqAll = unsafeRowSubqueryExpression "<> ALL"
1161−
1162−-- | >>> printSQL $ true `neqAny` values_ (true `as` #foo)
1163−-- TRUE <> ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1164−neqAny
1165− :: Expression grp commons schemas params from ty -- ^ expression
1166− -> Query commons schemas params '[alias ::: ty] -- ^ subquery
1167− -> Expression grp commons schemas params from (nullity 'PGbool)
1168−neqAny = unsafeSubqueryExpression "<> ANY"
1169−
1170−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1171−-- >>> printSQL $ myRow `rowNeqAny` values_ myRow
1172−-- ROW(1, FALSE) <> ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1173−rowNeqAny
1174− :: SListI row
1175− => NP (Aliased (Expression grp commons schemas params from)) row -- ^ row constructor
1176− -> Query commons schemas params row -- ^ subquery
1177− -> Expression grp commons schemas params from (nullity 'PGbool)
1178−rowNeqAny = unsafeRowSubqueryExpression "<> ANY"
1179−
1180−-- | >>> printSQL $ true `allLt` values_ (true `as` #foo)
1181−-- TRUE ALL < (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1182−allLt
1183− :: Expression grp commons schemas params from ty -- ^ expression
1184− -> Query commons schemas params '[alias ::: ty] -- ^ subquery
1185− -> Expression grp commons schemas params from (nullity 'PGbool)
1186−allLt = unsafeSubqueryExpression "ALL <"
1187−
1188−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1189−-- >>> printSQL $ myRow `rowLtAll` values_ myRow
1190−-- ROW(1, FALSE) ALL < (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1191−rowLtAll
1192− :: SListI row
1193− => NP (Aliased (Expression grp commons schemas params from)) row -- ^ row constructor
1194− -> Query commons schemas params row -- ^ subquery
1195− -> Expression grp commons schemas params from (nullity 'PGbool)
1196−rowLtAll = unsafeRowSubqueryExpression "ALL <"
1197−
1198−-- | >>> printSQL $ true `ltAny` values_ (true `as` #foo)
1199−-- TRUE ANY < (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1200−ltAny
1201− :: Expression grp commons schemas params from ty -- ^ expression
1202− -> Query commons schemas params '[alias ::: ty] -- ^ subquery
1203− -> Expression grp commons schemas params from (nullity 'PGbool)
1204−ltAny = unsafeSubqueryExpression "ANY <"
1205−
1206−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1207−-- >>> printSQL $ myRow `rowLtAll` values_ myRow
1208−-- ROW(1, FALSE) ALL < (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1209−rowLtAny
1210− :: SListI row
1211− => NP (Aliased (Expression grp commons schemas params from)) row -- ^ row constructor
1212− -> Query commons schemas params row -- ^ subquery
1213− -> Expression grp commons schemas params from (nullity 'PGbool)
1214−rowLtAny = unsafeRowSubqueryExpression "ANY <"
1215−
1216−-- | >>> printSQL $ true `lteAll` values_ (true `as` #foo)
1217−-- TRUE <= ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1218−lteAll
1219− :: Expression grp commons schemas params from ty -- ^ expression
1220− -> Query commons schemas params '[alias ::: ty] -- ^ subquery
1221− -> Expression grp commons schemas params from (nullity 'PGbool)
1222−lteAll = unsafeSubqueryExpression "<= ALL"
1223−
1224−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1225−-- >>> printSQL $ myRow `rowLteAll` values_ myRow
1226−-- ROW(1, FALSE) <= ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1227−rowLteAll
1228− :: SListI row
1229− => NP (Aliased (Expression grp commons schemas params from)) row -- ^ row constructor
1230− -> Query commons schemas params row -- ^ subquery
1231− -> Expression grp commons schemas params from (nullity 'PGbool)
1232−rowLteAll = unsafeRowSubqueryExpression "<= ALL"
1233−
1234−-- | >>> printSQL $ true `lteAny` values_ (true `as` #foo)
1235−-- TRUE <= ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1236−lteAny
1237− :: Expression grp commons schemas params from ty -- ^ expression
1238− -> Query commons schemas params '[alias ::: ty] -- ^ subquery
1239− -> Expression grp commons schemas params from (nullity 'PGbool)
1240−lteAny = unsafeSubqueryExpression "<= ANY"
1241−
1242−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1243−-- >>> printSQL $ myRow `rowLteAny` values_ myRow
1244−-- ROW(1, FALSE) <= ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1245−rowLteAny
1246− :: SListI row
1247− => NP (Aliased (Expression grp commons schemas params from)) row -- ^ row constructor
1248− -> Query commons schemas params row -- ^ subquery
1249− -> Expression grp commons schemas params from (nullity 'PGbool)
1250−rowLteAny = unsafeRowSubqueryExpression "<= ANY"
1251−
1252−-- | >>> printSQL $ true `gtAll` values_ (true `as` #foo)
1253−-- TRUE > ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1254−gtAll
1255− :: Expression grp commons schemas params from ty -- ^ expression
1256− -> Query commons schemas params '[alias ::: ty] -- ^ subquery
1257− -> Expression grp commons schemas params from (nullity 'PGbool)
1258−gtAll = unsafeSubqueryExpression "> ALL"
1259−
1260−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1261−-- >>> printSQL $ myRow `rowGtAll` values_ myRow
1262−-- ROW(1, FALSE) > ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1263−rowGtAll
1264− :: SListI row
1265− => NP (Aliased (Expression grp commons schemas params from)) row -- ^ row constructor
1266− -> Query commons schemas params row -- ^ subquery
1267− -> Expression grp commons schemas params from (nullity 'PGbool)
1268−rowGtAll = unsafeRowSubqueryExpression "> ALL"
1269−
1270−-- | >>> printSQL $ true `gtAny` values_ (true `as` #foo)
1271−-- TRUE > ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1272−gtAny
1273− :: Expression grp commons schemas params from ty -- ^ expression
1274− -> Query commons schemas params '[alias ::: ty] -- ^ subquery
1275− -> Expression grp commons schemas params from (nullity 'PGbool)
1276−gtAny = unsafeSubqueryExpression "> ANY"
1277−
1278−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1279−-- >>> printSQL $ myRow `rowGtAny` values_ myRow
1280−-- ROW(1, FALSE) > ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1281−rowGtAny
1282− :: SListI row
1283− => NP (Aliased (Expression grp commons schemas params from)) row -- ^ row constructor
1284− -> Query commons schemas params row -- ^ subquery
1285− -> Expression grp commons schemas params from (nullity 'PGbool)
1286−rowGtAny = unsafeRowSubqueryExpression "> ANY"
1287−
1288−-- | >>> printSQL $ true `gteAll` values_ (true `as` #foo)
1289−-- TRUE >= ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1290−gteAll
1291− :: Expression grp commons schemas params from ty -- ^ expression
1292− -> Query commons schemas params '[alias ::: ty] -- ^ subquery
1293− -> Expression grp commons schemas params from (nullity 'PGbool)
1294−gteAll = unsafeSubqueryExpression ">= ALL"
1295−
1296−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1297−-- >>> printSQL $ myRow `rowGteAll` values_ myRow
1298−-- ROW(1, FALSE) >= ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1299−rowGteAll
1300− :: SListI row
1301− => NP (Aliased (Expression grp commons schemas params from)) row -- ^ row constructor
1302− -> Query commons schemas params row -- ^ subquery
1303− -> Expression grp commons schemas params from (nullity 'PGbool)
1304−rowGteAll = unsafeRowSubqueryExpression ">= ALL"
1305−
1306−-- | >>> printSQL $ true `gteAny` values_ (true `as` #foo)
1307−-- TRUE >= ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1308−gteAny
1309− :: Expression grp commons schemas params from ty -- ^ expression
1310− -> Query commons schemas params '[alias ::: ty] -- ^ subquery
1311− -> Expression grp commons schemas params from (nullity 'PGbool)
1312−gteAny = unsafeSubqueryExpression ">= ANY"
1313−
1314−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1315−-- >>> printSQL $ myRow `rowGteAny` values_ myRow
1316−-- ROW(1, FALSE) >= ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1317−rowGteAny
1318− :: SListI row
1319− => NP (Aliased (Expression grp commons schemas params from)) row -- ^ row constructor
1320− -> Query commons schemas params row -- ^ subquery
1321− -> Expression grp commons schemas params from (nullity 'PGbool)
1322−rowGteAny = unsafeRowSubqueryExpression ">= ANY"
1148+notIn
1149+ :: Expression outer grp commons schemas params from ty -- ^ expression
1150+ -> [Expression outer grp commons schemas params from ty]
1151+ -> Condition outer grp commons schemas params from
1152+expr `notIn` exprs = UnsafeExpression $ renderSQL expr <+> "NOT IN"
1153+ <+> parenthesized (commaSeparated (renderSQL <$> exprs))
13231154
13241155-- | A `CommonTableExpression` is an auxiliary statement in a `with` clause.
13251156data CommonTableExpression statement
@@ -1360,7 +1191,7 @@ class With statement where
13601191 -> statement commons1 schemas params row
13611192 -- ^ larger query
13621193 -> statement commons0 schemas params row
1363−instance With Query where
1194+instance With (Query outer) where
13641195 with Done query = query
13651196 with ctes query = UnsafeQuery $
13661197 "WITH" <+> renderSQL ctes <+> renderSQL query