@@ -469,7 +469,7 @@ selectDistinct list rels = UnsafeQuery $
469469-- that the table expression produces.
470470selectStar
471471 :: HasUnique table from columns
472− => TableExpression schema params from 'Ungrouped
472+ => TableExpression db params from 'Ungrouped
473473 -- ^ intermediate virtual table
474474 -> Query db params columns
475475selectStar rels = UnsafeQuery $ "SELECT" <+> "*" <+> renderTableExpression rels
@@ -478,7 +478,7 @@ selectStar rels = UnsafeQuery $ "SELECT" <+> "*" <+> renderTableExpression rels
478478-- produces and eliminates duplicate rows.
479479selectDistinctStar
480480 :: HasUnique table from columns
481− => TableExpression schema params from 'Ungrouped
481+ => TableExpression db params from 'Ungrouped
482482 -- ^ intermediate virtual table
483483 -> Query db params columns
484484selectDistinctStar rels = UnsafeQuery $
@@ -490,7 +490,7 @@ selectDotStar
490490 :: Has table from columns
491491 => Alias table
492492 -- ^ particular virtual subtable
493− -> TableExpression schema params from 'Ungrouped
493+ -> TableExpression db params from 'Ungrouped
494494 -- ^ intermediate virtual table
495495 -> Query db params columns
496496selectDotStar rel tab = UnsafeQuery $
@@ -502,7 +502,7 @@ selectDistinctDotStar
502502 :: Has table from columns
503503 => Alias table
504504 -- ^ particular virtual table
505− -> TableExpression schema params from 'Ungrouped
505+ -> TableExpression db params from 'Ungrouped
506506 -- ^ intermediate virtual table
507507 -> Query db params columns
508508selectDistinctDotStar rel tab = UnsafeQuery $
@@ -520,8 +520,8 @@ selectDistinctDotStar rel tab = UnsafeQuery $
520520-- SELECT * FROM (VALUES (1, E'one')) AS t ("a", "b")
521521values
522522 :: SListI cols
523− => NP (Aliased (Expression schema '[] 'Ungrouped params)) cols
524− -> [NP (Aliased (Expression schema '[] 'Ungrouped params)) cols]
523+ => NP (Aliased (Expression db '[] 'Ungrouped params)) cols
524+ -> [NP (Aliased (Expression db '[] 'Ungrouped params)) cols]
525525 -- ^ When more than one row is specified, all the rows must
526526 -- must have the same number of elements
527527 -> Query db params cols
@@ -535,7 +535,7 @@ values rw rws = UnsafeQuery $ "SELECT * FROM"
535535 <+> parenthesized (renderCommaSeparated renderAliasPart rw)
536536 where
537537 renderAliasPart, renderValuePart
538− :: Aliased (Expression schema '[] 'Ungrouped params) ty -> ByteString
538+ :: Aliased (Expression db '[] 'Ungrouped params) ty -> ByteString
539539 renderAliasPart (_ `As` name) = renderAlias name
540540 renderValuePart (value `As` _) = renderExpression value
541541
@@ -543,7 +543,7 @@ values rw rws = UnsafeQuery $ "SELECT * FROM"
543543-- specified by value expressions.
544544values_
545545 :: SListI cols
546− => NP (Aliased (Expression schema '[] 'Ungrouped params)) cols
546+ => NP (Aliased (Expression db '[] 'Ungrouped params)) cols
547547 -- ^ one row of values
548548 -> Query db params cols
549549values_ rw = values rw []
@@ -607,7 +607,7 @@ data TableExpression
607607
608608-- | Render a `TableExpression`
609609renderTableExpression
610− :: TableExpression schema params from grouping
610+ :: TableExpression db params from grouping
611611 -> ByteString
612612renderTableExpression
613613 (TableExpression frm' whs' grps' hvs' srts' lims' offs') = mconcat
@@ -641,16 +641,16 @@ renderTableExpression
641641-- `group`, `having`, `orderBy`, `limit` and `offset`, using the `&` operator
642642-- to match the left-to-right sequencing of their placement in SQL.
643643from
644− :: FromClause schema params from -- ^ table reference
645− -> TableExpression schema params from 'Ungrouped
644+ :: FromClause db params from -- ^ table reference
645+ -> TableExpression db params from 'Ungrouped
646646from rels = TableExpression rels [] NoGroups NoHaving [] [] []
647647
648648-- | A `where_` is an endomorphism of `TableExpression`s which adds a
649649-- search condition to the `whereClause`.
650650where_
651− :: Condition schema from 'Ungrouped params -- ^ filtering condition
652− -> TableExpression schema params from grouping
653− -> TableExpression schema params from grouping
651+ :: Condition db from 'Ungrouped params -- ^ filtering condition
652+ -> TableExpression db params from grouping
653+ -> TableExpression db params from grouping
654654where_ wh rels = rels {whereClause = wh : whereClause rels}
655655
656656-- | A `groupBy` is a transformation of `TableExpression`s which switches
@@ -659,8 +659,8 @@ where_ wh rels = rels {whereClause = wh : whereClause rels}
659659groupBy
660660 :: SListI bys
661661 => NP (By from) bys -- ^ grouped columns
662− -> TableExpression schema params from 'Ungrouped
663− -> TableExpression schema params from ('Grouped bys)
662+ -> TableExpression db params from 'Ungrouped
663+ -> TableExpression db params from ('Grouped bys)
664664groupBy bys rels = TableExpression
665665 { fromClause = fromClause rels
666666 , whereClause = whereClause rels
@@ -674,34 +674,34 @@ groupBy bys rels = TableExpression
674674-- | A `having` is an endomorphism of `TableExpression`s which adds a
675675-- search condition to the `havingClause`.
676676having
677− :: Condition schema from ('Grouped bys) params -- ^ having condition
678− -> TableExpression schema params from ('Grouped bys)
679− -> TableExpression schema params from ('Grouped bys)
677+ :: Condition db from ('Grouped bys) params -- ^ having condition
678+ -> TableExpression db params from ('Grouped bys)
679+ -> TableExpression db params from ('Grouped bys)
680680having hv rels = rels
681681 { havingClause = case havingClause rels of Having hvs -> Having (hv:hvs) }
682682
683683-- | An `orderBy` is an endomorphism of `TableExpression`s which appends an
684684-- ordering to the right of the `orderByClause`.
685685orderBy
686− :: [SortExpression schema from grouping params] -- ^ sort expressions
687− -> TableExpression schema params from grouping
688− -> TableExpression schema params from grouping
686+ :: [SortExpression db from grouping params] -- ^ sort expressions
687+ -> TableExpression db params from grouping
688+ -> TableExpression db params from grouping
689689orderBy srts rels = rels {orderByClause = orderByClause rels ++ srts}
690690
691691-- | A `limit` is an endomorphism of `TableExpression`s which adds to the
692692-- `limitClause`.
693693limit
694694 :: Word64 -- ^ limit parameter
695− -> TableExpression schema params from grouping
696− -> TableExpression schema params from grouping
695+ -> TableExpression db params from grouping
696+ -> TableExpression db params from grouping
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 schema params from grouping
704− -> TableExpression schema params from grouping
703+ -> TableExpression db params from grouping
704+ -> TableExpression db params from grouping
705705offset off rels = rels {offsetClause = off : offsetClause rels}
706706
707707{-----------------------------------------
@@ -710,55 +710,55 @@ JSON stuff
710710
711711unsafeSetOfFunction
712712 :: ByteString
713− -> Expression schema '[] 'Ungrouped params ty
713+ -> Expression db '[] 'Ungrouped params ty
714714 -> Query db params row
715715unsafeSetOfFunction fun expr = UnsafeQuery $
716716 "SELECT * FROM " <> fun <> "(" <> renderExpression expr <> ")"
717717
718718-- | Expands the outermost JSON object into a set of key/value pairs.
719719jsonEach
720− :: Expression schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object
720+ :: Expression db '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object
721721 -> Query db 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 schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object
727+ :: Expression db '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object
728728 -> Query db 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 schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object
734+ :: Expression db '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object
735735 -> Query db 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 schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object
741+ :: Expression db '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object
742742 -> Query db 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 schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object
748+ :: Expression db '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object
749749 -> Query db 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 schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object
754+ :: Expression db '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object
755755 -> Query db params '["jsonb_object_keys" ::: 'NotNull 'PGtext]
756756jsonbObjectKeys = unsafeSetOfFunction "jsonb_object_keys"
757757
758758unsafePopulateFunction
759759 :: ByteString
760− -> TypeExpression schema (nullity ('PGcomposite row))
761− -> Expression schema '[] 'Ungrouped params ty
760+ -> TypeExpression db (nullity ('PGcomposite row))
761+ -> Expression db '[] 'Ungrouped params ty
762762 -> Query db params row
763763unsafePopulateFunction fun ty expr = UnsafeQuery $
764764 "SELECT * FROM " <> fun <> "("
@@ -768,24 +768,24 @@ unsafePopulateFunction fun ty expr = UnsafeQuery $
768768-- | Expands the JSON expression to a row whose columns match the record
769769-- type defined by the given table.
770770jsonPopulateRecord
771− :: TypeExpression schema (nullity ('PGcomposite row)) -- ^ row type
772− -> Expression schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object
771+ :: TypeExpression db (nullity ('PGcomposite row)) -- ^ row type
772+ -> Expression db '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object
773773 -> Query db 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
779− :: TypeExpression schema (nullity ('PGcomposite row)) -- ^ row type
780− -> Expression schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object
779+ :: TypeExpression db (nullity ('PGcomposite row)) -- ^ row type
780+ -> Expression db '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object
781781 -> Query db 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
787− :: TypeExpression schema (nullity ('PGcomposite row)) -- ^ row type
788− -> Expression schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json array
787+ :: TypeExpression db (nullity ('PGcomposite row)) -- ^ row type
788+ -> Expression db '[] 'Ungrouped params (nullity 'PGjson) -- ^ json array
789789 -> Query db params row
790790jsonPopulateRecordSet = unsafePopulateFunction "json_populate_record_set"
791791
@@ -793,55 +793,55 @@ jsonPopulateRecordSet = unsafePopulateFunction "json_populate_record_set"
793793-- to a set of rows whose columns match the record type defined by the given
794794-- table.
795795jsonbPopulateRecordSet
796− :: TypeExpression schema (nullity ('PGcomposite row)) -- ^ row type
797− -> Expression schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb array
796+ :: TypeExpression db (nullity ('PGcomposite row)) -- ^ row type
797+ -> Expression db '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb array
798798 -> Query db params row
799799jsonbPopulateRecordSet = unsafePopulateFunction "jsonb_populate_record_set"
800800
801801unsafeRecordFunction
802802 :: (SListI record, json `In` PGJsonType)
803803 => ByteString
804− -> Expression schema '[] 'Ungrouped params (nullity json)
805− -> NP (Aliased (TypeExpression schema)) record
804+ -> Expression db '[] 'Ungrouped params (nullity json)
805+ -> NP (Aliased (TypeExpression db)) record
806806 -> Query db params record
807807unsafeRecordFunction fun expr types = UnsafeQuery $
808808 "SELECT * FROM " <> fun <> "("
809809 <> renderExpression expr <> ")"
810810 <+> "AS" <+> "x" <> parenthesized (renderCommaSeparated renderTy types)
811811 where
812− renderTy :: Aliased (TypeExpression schema) ty -> ByteString
812+ renderTy :: Aliased (TypeExpression db) ty -> ByteString
813813 renderTy (ty `As` alias) =
814814 renderAlias alias <+> renderTypeExpression ty
815815
816816-- | Builds an arbitrary record from a JSON object.
817817jsonToRecord
818818 :: SListI record
819− => Expression schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object
820− -> NP (Aliased (TypeExpression schema)) record -- ^ record types
819+ => Expression db '[] 'Ungrouped params (nullity 'PGjson) -- ^ json object
820+ -> NP (Aliased (TypeExpression db)) record -- ^ record types
821821 -> Query db params record
822822jsonToRecord = unsafeRecordFunction "json_to_record"
823823
824824-- | Builds an arbitrary record from a binary JSON object.
825825jsonbToRecord
826826 :: SListI record
827− => Expression schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object
828− -> NP (Aliased (TypeExpression schema)) record -- ^ record types
827+ => Expression db '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb object
828+ -> NP (Aliased (TypeExpression db)) record -- ^ record types
829829 -> Query db 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 schema '[] 'Ungrouped params (nullity 'PGjson) -- ^ json array
836− -> NP (Aliased (TypeExpression schema)) record -- ^ record types
835+ => Expression db '[] 'Ungrouped params (nullity 'PGjson) -- ^ json array
836+ -> NP (Aliased (TypeExpression db)) record -- ^ record types
837837 -> Query db 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 schema '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb array
844− -> NP (Aliased (TypeExpression schema)) record -- ^ record types
843+ => Expression db '[] 'Ungrouped params (nullity 'PGjsonb) -- ^ jsonb array
844+ -> NP (Aliased (TypeExpression db)) record -- ^ record types
845845 -> Query db params record
846846jsonbToRecordSet = unsafeRecordFunction "jsonb_to_record_set"
847847
@@ -857,7 +857,7 @@ newtype FromClause db params from
857857 = UnsafeFromClause { renderFromClause :: ByteString }
858858 deriving (GHC.Generic,Show,Eq,Ord,NFData)
859859
860−-- | A real `table` is a table from the schema.
860+-- | A real `table` is a table from the database.
861861table
862862 :: (Has sch db schema, Has tab schema ('Table table))
863863 => Aliased (QualifiedAlias sch) (alias ::: tab)
@@ -868,7 +868,7 @@ table (tab `As` alias) = UnsafeFromClause $
868868-- | `subquery` derives a table from a `Query`.
869869subquery
870870 :: Aliased (Query db params) query
871− -> FromClause schema params '[query]
871+ -> FromClause db params '[query]
872872subquery = UnsafeFromClause . renderAliasedAs (parenthesized . renderQuery)
873873
874874-- | `view` derives a table from a `View`.
@@ -886,11 +886,11 @@ view (vw `As` alias) = UnsafeFromClause $
886886 have @n * m@ rows.
887887-}
888888crossJoin
889− :: FromClause schema params right
889+ :: FromClause db params right
890890 -- ^ right
891− -> FromClause schema params left
891+ -> FromClause db params left
892892 -- ^ left
893− -> FromClause schema params (Join left right)
893+ -> FromClause db params (Join left right)
894894crossJoin right left = UnsafeFromClause $
895895 renderFromClause left <+> "CROSS JOIN" <+> renderFromClause right
896896
@@ -898,13 +898,13 @@ crossJoin right left = UnsafeFromClause $
898898the @on@ condition.
899899-}
900900innerJoin
901− :: FromClause schema params right
901+ :: FromClause db params right
902902 -- ^ right
903− -> Condition schema (Join left right) 'Ungrouped params
903+ -> Condition db (Join left right) 'Ungrouped params
904904 -- ^ @on@ condition
905− -> FromClause schema params left
905+ -> FromClause db params left
906906 -- ^ left
907− -> FromClause schema params (Join left right)
907+ -> FromClause db params (Join left right)
908908innerJoin right on left = UnsafeFromClause $
909909 renderFromClause left <+> "INNER JOIN" <+> renderFromClause right
910910 <+> "ON" <+> renderExpression on
@@ -915,13 +915,13 @@ innerJoin right on left = UnsafeFromClause $
915915 Thus, the joined table always has at least one row for each row in @left@.
916916-}
917917leftOuterJoin
918− :: FromClause schema params right
918+ :: FromClause db params right
919919 -- ^ right
920− -> Condition schema (Join left right) 'Ungrouped params
920+ -> Condition db (Join left right) 'Ungrouped params
921921 -- ^ @on@ condition
922− -> FromClause schema params left
922+ -> FromClause db params left
923923 -- ^ left
924− -> FromClause schema params (Join left (NullifyFrom right))
924+ -> FromClause db params (Join left (NullifyFrom right))
925925leftOuterJoin right on left = UnsafeFromClause $
926926 renderFromClause left <+> "LEFT OUTER JOIN" <+> renderFromClause right
927927 <+> "ON" <+> renderExpression on
@@ -933,13 +933,13 @@ leftOuterJoin right on left = UnsafeFromClause $
933933 have a row for each row in @right@.
934934-}
935935rightOuterJoin
936− :: FromClause schema params right
936+ :: FromClause db params right
937937 -- ^ right
938− -> Condition schema (Join left right) 'Ungrouped params
938+ -> Condition db (Join left right) 'Ungrouped params
939939 -- ^ @on@ condition
940− -> FromClause schema params left
940+ -> FromClause db params left
941941 -- ^ left
942− -> FromClause schema params (Join (NullifyFrom left) right)
942+ -> FromClause db params (Join (NullifyFrom left) right)
943943rightOuterJoin right on left = UnsafeFromClause $
944944 renderFromClause left <+> "RIGHT OUTER JOIN" <+> renderFromClause right
945945 <+> "ON" <+> renderExpression on
@@ -952,13 +952,13 @@ rightOuterJoin right on left = UnsafeFromClause $
952952 is added.
953953-}
954954fullOuterJoin
955− :: FromClause schema params right
955+ :: FromClause db params right
956956 -- ^ right
957− -> Condition schema (Join left right) 'Ungrouped params
957+ -> Condition db (Join left right) 'Ungrouped params
958958 -- ^ @on@ condition
959− -> FromClause schema params left
959+ -> FromClause db params left
960960 -- ^ left
961− -> FromClause schema params
961+ -> FromClause db params
962962 (Join (NullifyFrom left) (NullifyFrom right))
963963fullOuterJoin right on left = UnsafeFromClause $
964964 renderFromClause left <+> "FULL OUTER JOIN" <+> renderFromClause right
@@ -1029,17 +1029,17 @@ renderGroupByClause = \case
10291029-- An `Ungrouped` `TableExpression` may only use `NoHaving` while a `Grouped`
10301030-- `TableExpression` must use `Having` whose conditions are combined with
10311031-- `.&&`.
1032−data HavingClause schema from grouping params where
1033− NoHaving :: HavingClause schema from 'Ungrouped params
1032+data HavingClause db from grouping params where
1033+ NoHaving :: HavingClause db from 'Ungrouped params
10341034 Having
1035− :: [Condition schema from ('Grouped bys) params]
1036− -> HavingClause schema from ('Grouped bys) params
1037−deriving instance Show (HavingClause schema from grouping params)
1038−deriving instance Eq (HavingClause schema from grouping params)
1039−deriving instance Ord (HavingClause schema from grouping params)
1035+ :: [Condition db from ('Grouped bys) params]
1036+ -> HavingClause db from ('Grouped bys) params
1037+deriving instance Show (HavingClause db from grouping params)
1038+deriving instance Eq (HavingClause db from grouping params)
1039+deriving instance Ord (HavingClause db from grouping params)
10401040
10411041-- | Render a `HavingClause`.
1042−renderHavingClause :: HavingClause schema from grouping params -> ByteString
1042+renderHavingClause :: HavingClause db from grouping params -> ByteString
10431043renderHavingClause = \case
10441044 NoHaving -> ""
10451045 Having [] -> ""
@@ -1058,29 +1058,29 @@ Sorting
10581058-- `AscNullsLast`, `DescNullsFirst` and `DescNullsLast` options are used to
10591059-- determine whether nulls appear before or after non-null values in the sort
10601060-- ordering of a `Null` result column.
1061−data SortExpression schema from grouping params where
1061+data SortExpression db from grouping params where
10621062 Asc
1063− :: Expression schema from grouping params ('NotNull ty)
1064− -> SortExpression schema from grouping params
1063+ :: Expression db from grouping params ('NotNull ty)
1064+ -> SortExpression db from grouping params
10651065 Desc
1066− :: Expression schema from grouping params ('NotNull ty)
1067− -> SortExpression schema from grouping params
1066+ :: Expression db from grouping params ('NotNull ty)
1067+ -> SortExpression db from grouping params
10681068 AscNullsFirst
1069− :: Expression schema from grouping params ('Null ty)
1070− -> SortExpression schema from grouping params
1069+ :: Expression db from grouping params ('Null ty)
1070+ -> SortExpression db from grouping params
10711071 AscNullsLast
1072− :: Expression schema from grouping params ('Null ty)
1073− -> SortExpression schema from grouping params
1072+ :: Expression db from grouping params ('Null ty)
1073+ -> SortExpression db from grouping params
10741074 DescNullsFirst
1075− :: Expression schema from grouping params ('Null ty)
1076− -> SortExpression schema from grouping params
1075+ :: Expression db from grouping params ('Null ty)
1076+ -> SortExpression db from grouping params
10771077 DescNullsLast
1078− :: Expression schema from grouping params ('Null ty)
1079− -> SortExpression schema from grouping params
1080−deriving instance Show (SortExpression schema from grouping params)
1078+ :: Expression db from grouping params ('Null ty)
1079+ -> SortExpression db from grouping params
1080+deriving instance Show (SortExpression db from grouping params)
10811081
10821082-- | Render a `SortExpression`.
1083−renderSortExpression :: SortExpression schema from grouping params -> ByteString
1083+renderSortExpression :: SortExpression db from grouping params -> ByteString
10841084renderSortExpression = \case
10851085 Asc expression -> renderExpression expression <+> "ASC"
10861086 Desc expression -> renderExpression expression <+> "DESC"
@@ -1093,18 +1093,18 @@ renderSortExpression = \case
10931093
10941094unsafeSubqueryExpression
10951095 :: ByteString
1096− -> Expression schema from grp params ty
1096+ -> Expression db from grp params ty
10971097 -> Query db params '[alias ::: ty]
1098− -> Expression schema from grp params (nullity 'PGbool)
1098+ -> Expression db from grp params (nullity 'PGbool)
10991099unsafeSubqueryExpression op x q = UnsafeExpression $
11001100 renderExpression x <+> op <+> parenthesized (renderQuery q)
11011101
11021102unsafeRowSubqueryExpression
11031103 :: SListI row
11041104 => ByteString
1105− -> NP (Aliased (Expression schema from grp params)) row
1105+ -> NP (Aliased (Expression db from grp params)) row
11061106 -> Query db params row
1107− -> Expression schema from grp params (nullity 'PGbool)
1107+ -> Expression db from grp params (nullity 'PGbool)
11081108unsafeRowSubqueryExpression op xs q = UnsafeExpression $
11091109 renderExpression (row xs) <+> op <+> parenthesized (renderQuery q)
11101110
@@ -1117,9 +1117,9 @@ unsafeRowSubqueryExpression op xs q = UnsafeExpression $
11171117-- >>> printSQL $ true `in_` values_ (true `as` #foo)
11181118-- TRUE IN (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
11191119in_
1120− :: Expression schema from grp params ty -- ^ expression
1120+ :: Expression db from grp params ty -- ^ expression
11211121 -> Query db params '[alias ::: ty] -- ^ subquery
1122− -> Expression schema from grp params (nullity 'PGbool)
1122+ -> Expression db from grp params (nullity 'PGbool)
11231123in_ = unsafeSubqueryExpression "IN"
11241124
11251125{- | The left-hand side of this form of `rowIn` is a row constructor.
@@ -1138,17 +1138,17 @@ ROW(1, FALSE) IN (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
11381138-}
11391139rowIn
11401140 :: SListI row
1141− => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor
1141+ => NP (Aliased (Expression db from grp params)) row -- ^ row constructor
11421142 -> Query db params row -- ^ subquery
1143− -> Expression schema from grp params (nullity 'PGbool)
1143+ -> Expression db from grp params (nullity 'PGbool)
11441144rowIn = unsafeRowSubqueryExpression "IN"
11451145
11461146-- | >>> printSQL $ true `eqAll` values_ (true `as` #foo)
11471147-- TRUE = ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
11481148eqAll
1149− :: Expression schema from grp params ty -- ^ expression
1149+ :: Expression db from grp params ty -- ^ expression
11501150 -> Query db params '[alias ::: ty] -- ^ subquery
1151− -> Expression schema from grp params (nullity 'PGbool)
1151+ -> Expression db from grp params (nullity 'PGbool)
11521152eqAll = unsafeSubqueryExpression "= ALL"
11531153
11541154-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
@@ -1156,17 +1156,17 @@ eqAll = unsafeSubqueryExpression "= ALL"
11561156-- ROW(1, FALSE) = ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
11571157rowEqAll
11581158 :: SListI row
1159− => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor
1159+ => NP (Aliased (Expression db from grp params)) row -- ^ row constructor
11601160 -> Query db params row -- ^ subquery
1161− -> Expression schema from grp params (nullity 'PGbool)
1161+ -> Expression db from grp params (nullity 'PGbool)
11621162rowEqAll = unsafeRowSubqueryExpression "= ALL"
11631163
11641164-- | >>> printSQL $ true `eqAny` values_ (true `as` #foo)
11651165-- TRUE = ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
11661166eqAny
1167− :: Expression schema from grp params ty -- ^ expression
1167+ :: Expression db from grp params ty -- ^ expression
11681168 -> Query db params '[alias ::: ty] -- ^ subquery
1169− -> Expression schema from grp params (nullity 'PGbool)
1169+ -> Expression db from grp params (nullity 'PGbool)
11701170eqAny = unsafeSubqueryExpression "= ANY"
11711171
11721172-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
@@ -1174,17 +1174,17 @@ eqAny = unsafeSubqueryExpression "= ANY"
11741174-- ROW(1, FALSE) = ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
11751175rowEqAny
11761176 :: SListI row
1177− => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor
1177+ => NP (Aliased (Expression db from grp params)) row -- ^ row constructor
11781178 -> Query db params row -- ^ subquery
1179− -> Expression schema from grp params (nullity 'PGbool)
1179+ -> Expression db from grp params (nullity 'PGbool)
11801180rowEqAny = unsafeRowSubqueryExpression "= ANY"
11811181
11821182-- | >>> printSQL $ true `neqAll` values_ (true `as` #foo)
11831183-- TRUE <> ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
11841184neqAll
1185− :: Expression schema from grp params ty -- ^ expression
1185+ :: Expression db from grp params ty -- ^ expression
11861186 -> Query db params '[alias ::: ty] -- ^ subquery
1187− -> Expression schema from grp params (nullity 'PGbool)
1187+ -> Expression db from grp params (nullity 'PGbool)
11881188neqAll = unsafeSubqueryExpression "<> ALL"
11891189
11901190-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
@@ -1192,17 +1192,17 @@ neqAll = unsafeSubqueryExpression "<> ALL"
11921192-- ROW(1, FALSE) <> ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
11931193rowNeqAll
11941194 :: SListI row
1195− => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor
1195+ => NP (Aliased (Expression db from grp params)) row -- ^ row constructor
11961196 -> Query db params row -- ^ subquery
1197− -> Expression schema from grp params (nullity 'PGbool)
1197+ -> Expression db from grp params (nullity 'PGbool)
11981198rowNeqAll = unsafeRowSubqueryExpression "<> ALL"
11991199
12001200-- | >>> printSQL $ true `neqAny` values_ (true `as` #foo)
12011201-- TRUE <> ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
12021202neqAny
1203− :: Expression schema from grp params ty -- ^ expression
1203+ :: Expression db from grp params ty -- ^ expression
12041204 -> Query db params '[alias ::: ty] -- ^ subquery
1205− -> Expression schema from grp params (nullity 'PGbool)
1205+ -> Expression db from grp params (nullity 'PGbool)
12061206neqAny = unsafeSubqueryExpression "<> ANY"
12071207
12081208-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
@@ -1210,17 +1210,17 @@ neqAny = unsafeSubqueryExpression "<> ANY"
12101210-- ROW(1, FALSE) <> ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
12111211rowNeqAny
12121212 :: SListI row
1213− => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor
1213+ => NP (Aliased (Expression db from grp params)) row -- ^ row constructor
12141214 -> Query db params row -- ^ subquery
1215− -> Expression schema from grp params (nullity 'PGbool)
1215+ -> Expression db from grp params (nullity 'PGbool)
12161216rowNeqAny = unsafeRowSubqueryExpression "<> ANY"
12171217
12181218-- | >>> printSQL $ true `allLt` values_ (true `as` #foo)
12191219-- TRUE ALL < (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
12201220allLt
1221− :: Expression schema from grp params ty -- ^ expression
1221+ :: Expression db from grp params ty -- ^ expression
12221222 -> Query db params '[alias ::: ty] -- ^ subquery
1223− -> Expression schema from grp params (nullity 'PGbool)
1223+ -> Expression db from grp params (nullity 'PGbool)
12241224allLt = unsafeSubqueryExpression "ALL <"
12251225
12261226-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
@@ -1228,17 +1228,17 @@ allLt = unsafeSubqueryExpression "ALL <"
12281228-- ROW(1, FALSE) ALL < (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
12291229rowLtAll
12301230 :: SListI row
1231− => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor
1231+ => NP (Aliased (Expression db from grp params)) row -- ^ row constructor
12321232 -> Query db params row -- ^ subquery
1233− -> Expression schema from grp params (nullity 'PGbool)
1233+ -> Expression db from grp params (nullity 'PGbool)
12341234rowLtAll = unsafeRowSubqueryExpression "ALL <"
12351235
12361236-- | >>> printSQL $ true `ltAny` values_ (true `as` #foo)
12371237-- TRUE ANY < (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
12381238ltAny
1239− :: Expression schema from grp params ty -- ^ expression
1239+ :: Expression db from grp params ty -- ^ expression
12401240 -> Query db params '[alias ::: ty] -- ^ subquery
1241− -> Expression schema from grp params (nullity 'PGbool)
1241+ -> Expression db from grp params (nullity 'PGbool)
12421242ltAny = unsafeSubqueryExpression "ANY <"
12431243
12441244-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
@@ -1246,17 +1246,17 @@ ltAny = unsafeSubqueryExpression "ANY <"
12461246-- ROW(1, FALSE) ALL < (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
12471247rowLtAny
12481248 :: SListI row
1249− => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor
1249+ => NP (Aliased (Expression db from grp params)) row -- ^ row constructor
12501250 -> Query db params row -- ^ subquery
1251− -> Expression schema from grp params (nullity 'PGbool)
1251+ -> Expression db from grp params (nullity 'PGbool)
12521252rowLtAny = unsafeRowSubqueryExpression "ANY <"
12531253
12541254-- | >>> printSQL $ true `lteAll` values_ (true `as` #foo)
12551255-- TRUE <= ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
12561256lteAll
1257− :: Expression schema from grp params ty -- ^ expression
1257+ :: Expression db from grp params ty -- ^ expression
12581258 -> Query db params '[alias ::: ty] -- ^ subquery
1259− -> Expression schema from grp params (nullity 'PGbool)
1259+ -> Expression db from grp params (nullity 'PGbool)
12601260lteAll = unsafeSubqueryExpression "<= ALL"
12611261
12621262-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
@@ -1264,17 +1264,17 @@ lteAll = unsafeSubqueryExpression "<= ALL"
12641264-- ROW(1, FALSE) <= ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
12651265rowLteAll
12661266 :: SListI row
1267− => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor
1267+ => NP (Aliased (Expression db from grp params)) row -- ^ row constructor
12681268 -> Query db params row -- ^ subquery
1269− -> Expression schema from grp params (nullity 'PGbool)
1269+ -> Expression db from grp params (nullity 'PGbool)
12701270rowLteAll = unsafeRowSubqueryExpression "<= ALL"
12711271
12721272-- | >>> printSQL $ true `lteAny` values_ (true `as` #foo)
12731273-- TRUE <= ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
12741274lteAny
1275− :: Expression schema from grp params ty -- ^ expression
1275+ :: Expression db from grp params ty -- ^ expression
12761276 -> Query db params '[alias ::: ty] -- ^ subquery
1277− -> Expression schema from grp params (nullity 'PGbool)
1277+ -> Expression db from grp params (nullity 'PGbool)
12781278lteAny = unsafeSubqueryExpression "<= ANY"
12791279
12801280-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
@@ -1282,17 +1282,17 @@ lteAny = unsafeSubqueryExpression "<= ANY"
12821282-- ROW(1, FALSE) <= ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
12831283rowLteAny
12841284 :: SListI row
1285− => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor
1285+ => NP (Aliased (Expression db from grp params)) row -- ^ row constructor
12861286 -> Query db params row -- ^ subquery
1287− -> Expression schema from grp params (nullity 'PGbool)
1287+ -> Expression db from grp params (nullity 'PGbool)
12881288rowLteAny = unsafeRowSubqueryExpression "<= ANY"
12891289
12901290-- | >>> printSQL $ true `gtAll` values_ (true `as` #foo)
12911291-- TRUE > ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
12921292gtAll
1293− :: Expression schema from grp params ty -- ^ expression
1293+ :: Expression db from grp params ty -- ^ expression
12941294 -> Query db params '[alias ::: ty] -- ^ subquery
1295− -> Expression schema from grp params (nullity 'PGbool)
1295+ -> Expression db from grp params (nullity 'PGbool)
12961296gtAll = unsafeSubqueryExpression "> ALL"
12971297
12981298-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
@@ -1300,17 +1300,17 @@ gtAll = unsafeSubqueryExpression "> ALL"
13001300-- ROW(1, FALSE) > ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
13011301rowGtAll
13021302 :: SListI row
1303− => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor
1303+ => NP (Aliased (Expression db from grp params)) row -- ^ row constructor
13041304 -> Query db params row -- ^ subquery
1305− -> Expression schema from grp params (nullity 'PGbool)
1305+ -> Expression db from grp params (nullity 'PGbool)
13061306rowGtAll = unsafeRowSubqueryExpression "> ALL"
13071307
13081308-- | >>> printSQL $ true `gtAny` values_ (true `as` #foo)
13091309-- TRUE > ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
13101310gtAny
1311− :: Expression schema from grp params ty -- ^ expression
1311+ :: Expression db from grp params ty -- ^ expression
13121312 -> Query db params '[alias ::: ty] -- ^ subquery
1313− -> Expression schema from grp params (nullity 'PGbool)
1313+ -> Expression db from grp params (nullity 'PGbool)
13141314gtAny = unsafeSubqueryExpression "> ANY"
13151315
13161316-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
@@ -1318,17 +1318,17 @@ gtAny = unsafeSubqueryExpression "> ANY"
13181318-- ROW(1, FALSE) > ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
13191319rowGtAny
13201320 :: SListI row
1321− => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor
1321+ => NP (Aliased (Expression db from grp params)) row -- ^ row constructor
13221322 -> Query db params row -- ^ subquery
1323− -> Expression schema from grp params (nullity 'PGbool)
1323+ -> Expression db from grp params (nullity 'PGbool)
13241324rowGtAny = unsafeRowSubqueryExpression "> ANY"
13251325
13261326-- | >>> printSQL $ true `gteAll` values_ (true `as` #foo)
13271327-- TRUE >= ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
13281328gteAll
1329− :: Expression schema from grp params ty -- ^ expression
1329+ :: Expression db from grp params ty -- ^ expression
13301330 -> Query db params '[alias ::: ty] -- ^ subquery
1331− -> Expression schema from grp params (nullity 'PGbool)
1331+ -> Expression db from grp params (nullity 'PGbool)
13321332gteAll = unsafeSubqueryExpression ">= ALL"
13331333
13341334-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
@@ -1336,17 +1336,17 @@ gteAll = unsafeSubqueryExpression ">= ALL"
13361336-- ROW(1, FALSE) >= ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
13371337rowGteAll
13381338 :: SListI row
1339− => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor
1339+ => NP (Aliased (Expression db from grp params)) row -- ^ row constructor
13401340 -> Query db params row -- ^ subquery
1341− -> Expression schema from grp params (nullity 'PGbool)
1341+ -> Expression db from grp params (nullity 'PGbool)
13421342rowGteAll = unsafeRowSubqueryExpression ">= ALL"
13431343
13441344-- | >>> printSQL $ true `gteAny` values_ (true `as` #foo)
13451345-- TRUE >= ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
13461346gteAny
1347− :: Expression schema from grp params ty -- ^ expression
1347+ :: Expression db from grp params ty -- ^ expression
13481348 -> Query db params '[alias ::: ty] -- ^ subquery
1349− -> Expression schema from grp params (nullity 'PGbool)
1349+ -> Expression db from grp params (nullity 'PGbool)
13501350gteAny = unsafeSubqueryExpression ">= ANY"
13511351
13521352-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
@@ -1354,9 +1354,9 @@ gteAny = unsafeSubqueryExpression ">= ANY"
13541354-- ROW(1, FALSE) >= ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
13551355rowGteAny
13561356 :: SListI row
1357− => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor
1357+ => NP (Aliased (Expression db from grp params)) row -- ^ row constructor
13581358 -> Query db params row -- ^ subquery
1359− -> Expression schema from grp params (nullity 'PGbool)
1359+ -> Expression db from grp params (nullity 'PGbool)
13601360rowGteAny = unsafeRowSubqueryExpression ">= ANY"
13611361
13621362-- | A `CommonTableExpression` is an auxiliary statement in a `with` clause.