@@ -93,31 +93,10 @@ module Squeal.PostgreSQL.Query
9393 -- * Subquery Expressions
9494 , exists
9595 , in_
96− , rowIn
97− , eqAll
98− , rowEqAll
99− , eqAny
100− , rowEqAny
101− , neqAll
102− , rowNeqAll
103− , neqAny
104− , rowNeqAny
105− , allLt
106− , rowLtAll
107− , ltAny
108− , rowLtAny
109− , lteAll
110− , rowLteAll
111− , lteAny
112− , rowLteAny
113− , gtAll
114− , rowGtAll
115− , gtAny
116− , rowGtAny
117− , gteAll
118− , rowGteAll
119− , gteAny
120− , rowGteAny
96+ , notIn
97+ , Operator
98+ , subAll
99+ , subAny
121100 ) where
122101
123102import Control.DeepSeq
@@ -128,6 +107,7 @@ import Data.Word
128107import Generics.SOP hiding (from)
129108import GHC.TypeLits
130109
110+import qualified Data.ByteString as ByteString
131111import qualified GHC.Generics as GHC
132112
133113import Squeal.PostgreSQL.Expression
@@ -1073,278 +1053,104 @@ instance RenderSQL (HavingClause outer grp commons schemas params from) where
10731053 Having conditions ->
10741054 " HAVING" <+> commaSeparated (renderSQL <$> conditions)
10751055
1076−unsafeSubqueryExpression
1077− :: ByteString
1078− -> Expression outer grp commons schemas params from ty
1079− -> Query (Join outer from) commons schemas params '[alias ::: ty]
1080− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1081−unsafeSubqueryExpression op x q = UnsafeExpression $
1082− renderSQL x <+> op <+> parenthesized (renderSQL q)
1083−
1084−unsafeRowSubqueryExpression
1085− :: SListI row
1086− => ByteString
1087− -> NP (Aliased (Expression outer grp commons schemas params from)) row
1088− -> Query (Join outer from) commons schemas params row
1089− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1090−unsafeRowSubqueryExpression op xs q = UnsafeExpression $
1091− renderSQL (row xs) <+> op <+> parenthesized (renderSQL q)
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.
10921064
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+-}
10931068exists
10941069 :: Query (Join outer from) commons schemas params row
10951070 -> Condition outer grp commons schemas params from
10961071exists query = UnsafeExpression $ "EXISTS" <+> parenthesized (renderSQL query)
10971072
1098−-- | The right-hand side is a sub`Query`, which must return exactly one column.
1099−-- The left-hand expression is evaluated and compared to each row of the
1100−-- sub`Query` result. The result of `in_` is `true` if any equal subquery row is found.
1101−-- The result is `false` if no equal row is found
1102−-- (including the case where the subquery returns no rows).
1103−--
1104−-- >>> printSQL $ true `in_` values_ (true `as` #foo)
1105−-- TRUE IN (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1106−in_
1107− :: Expression outer grp commons schemas params from ty -- ^ expression
1108− -> Query (Join outer from) commons schemas params '[alias ::: ty] -- ^ subquery
1109− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1110−in_ = unsafeSubqueryExpression "IN"
1111−
1112−{- | The left-hand side of this form of `rowIn` is a row constructor.
1113−The right-hand side is a sub`Query`,
1114−which must return exactly as many columns as
1115−there are expressions in the left-hand row.
1116−The left-hand expressions are evaluated and compared row-wise to each row
1117−of the subquery result. The result of `rowIn`
1118−is `true` if any equal subquery row is found.
1119−The result is `false` if no equal row is found
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
11201111(including the case where the subquery returns no rows).
11211112
1122−>>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression outer grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1123−>>> printSQL $ myRow `rowIn` values_ myRow
1124−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"))
11251115-}
1126−rowIn
1127− :: SListI row
1128− => NP (Aliased (Expression outer grp commons schemas params from)) row -- ^ row constructor
1129− -> Query (Join outer from) commons schemas params row -- ^ subquery
1130− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1131−rowIn = unsafeRowSubqueryExpression "IN"
1132−
1133−-- | >>> printSQL $ true `eqAll` values_ (true `as` #foo)
1134−-- TRUE = ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1135−eqAll
1136− :: Expression outer grp commons schemas params from ty -- ^ expression
1137− -> Query (Join outer from) commons schemas params '[alias ::: ty] -- ^ subquery
1138− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1139−eqAll = unsafeSubqueryExpression "= ALL"
1140−
1141−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression outer grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1142−-- >>> printSQL $ myRow `rowEqAll` values_ myRow
1143−-- ROW(1, FALSE) = ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1144−rowEqAll
1145− :: SListI row
1146− => NP (Aliased (Expression outer grp commons schemas params from)) row -- ^ row constructor
1147− -> Query (Join outer from) commons schemas params row -- ^ subquery
1148− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1149−rowEqAll = unsafeRowSubqueryExpression "= ALL"
1150−
1151−-- | >>> printSQL $ true `eqAny` values_ (true `as` #foo)
1152−-- TRUE = ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1153−eqAny
1154− :: Expression outer grp commons schemas params from ty -- ^ expression
1155− -> Query (Join outer from) commons schemas params '[alias ::: ty] -- ^ subquery
1156− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1157−eqAny = unsafeSubqueryExpression "= ANY"
1158−
1159−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression outer grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1160−-- >>> printSQL $ myRow `rowEqAny` values_ myRow
1161−-- ROW(1, FALSE) = ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1162−rowEqAny
1163− :: SListI row
1164− => NP (Aliased (Expression outer grp commons schemas params from)) row -- ^ row constructor
1165− -> Query (Join outer from) commons schemas params row -- ^ subquery
1166− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1167−rowEqAny = unsafeRowSubqueryExpression "= ANY"
1168−
1169−-- | >>> printSQL $ true `neqAll` values_ (true `as` #foo)
1170−-- TRUE <> ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1171−neqAll
1172− :: Expression outer grp commons schemas params from ty -- ^ expression
1173− -> Query (Join outer from) commons schemas params '[alias ::: ty] -- ^ subquery
1174− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1175−neqAll = unsafeSubqueryExpression "<> ALL"
1176−
1177−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression outer grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1178−-- >>> printSQL $ myRow `rowNeqAll` values_ myRow
1179−-- ROW(1, FALSE) <> ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1180−rowNeqAll
1181− :: SListI row
1182− => NP (Aliased (Expression outer grp commons schemas params from)) row -- ^ row constructor
1183− -> Query (Join outer from) commons schemas params row -- ^ subquery
1184− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1185−rowNeqAll = unsafeRowSubqueryExpression "<> ALL"
1186−
1187−-- | >>> printSQL $ true `neqAny` values_ (true `as` #foo)
1188−-- TRUE <> ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1189−neqAny
1190− :: Expression outer grp commons schemas params from ty -- ^ expression
1191− -> Query (Join outer from) commons schemas params '[alias ::: ty] -- ^ subquery
1192− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1193−neqAny = unsafeSubqueryExpression "<> ANY"
1194−
1195−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression outer grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1196−-- >>> printSQL $ myRow `rowNeqAny` values_ myRow
1197−-- ROW(1, FALSE) <> ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1198−rowNeqAny
1199− :: SListI row
1200− => NP (Aliased (Expression outer grp commons schemas params from)) row -- ^ row constructor
1201− -> Query (Join outer from) commons schemas params row -- ^ subquery
1202− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1203−rowNeqAny = unsafeRowSubqueryExpression "<> ANY"
1204−
1205−-- | >>> printSQL $ true `allLt` values_ (true `as` #foo)
1206−-- TRUE ALL < (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1207−allLt
1208− :: Expression outer grp commons schemas params from ty -- ^ expression
1209− -> Query (Join outer from) commons schemas params '[alias ::: ty] -- ^ subquery
1210− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1211−allLt = unsafeSubqueryExpression "ALL <"
1212−
1213−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression outer grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1214−-- >>> printSQL $ myRow `rowLtAll` values_ myRow
1215−-- ROW(1, FALSE) ALL < (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1216−rowLtAll
1217− :: SListI row
1218− => NP (Aliased (Expression outer grp commons schemas params from)) row -- ^ row constructor
1219− -> Query (Join outer from) commons schemas params row -- ^ subquery
1220− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1221−rowLtAll = unsafeRowSubqueryExpression "ALL <"
1222−
1223−-- | >>> printSQL $ true `ltAny` values_ (true `as` #foo)
1224−-- TRUE ANY < (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1225−ltAny
1226− :: Expression outer grp commons schemas params from ty -- ^ expression
1227− -> Query (Join outer from) commons schemas params '[alias ::: ty] -- ^ subquery
1228− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1229−ltAny = unsafeSubqueryExpression "ANY <"
1230−
1231−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression outer grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1232−-- >>> printSQL $ myRow `rowLtAll` values_ myRow
1233−-- ROW(1, FALSE) ALL < (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1234−rowLtAny
1235− :: SListI row
1236− => NP (Aliased (Expression outer grp commons schemas params from)) row -- ^ row constructor
1237− -> Query (Join outer from) commons schemas params row -- ^ subquery
1238− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1239−rowLtAny = unsafeRowSubqueryExpression "ANY <"
1240−
1241−-- | >>> printSQL $ true `lteAll` values_ (true `as` #foo)
1242−-- TRUE <= ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1243−lteAll
1244− :: Expression outer grp commons schemas params from ty -- ^ expression
1245− -> Query (Join outer from) commons schemas params '[alias ::: ty] -- ^ subquery
1246− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1247−lteAll = unsafeSubqueryExpression "<= ALL"
1248−
1249−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression outer grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1250−-- >>> printSQL $ myRow `rowLteAll` values_ myRow
1251−-- ROW(1, FALSE) <= ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1252−rowLteAll
1253− :: SListI row
1254− => NP (Aliased (Expression outer grp commons schemas params from)) row -- ^ row constructor
1255− -> Query (Join outer from) commons schemas params row -- ^ subquery
1256− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1257−rowLteAll = unsafeRowSubqueryExpression "<= ALL"
1258−
1259−-- | >>> printSQL $ true `lteAny` values_ (true `as` #foo)
1260−-- TRUE <= ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1261−lteAny
1262− :: Expression outer grp commons schemas params from ty -- ^ expression
1263− -> Query (Join outer from) commons schemas params '[alias ::: ty] -- ^ subquery
1264− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1265−lteAny = unsafeSubqueryExpression "<= ANY"
1266−
1267−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression outer grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1268−-- >>> printSQL $ myRow `rowLteAny` values_ myRow
1269−-- ROW(1, FALSE) <= ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1270−rowLteAny
1271− :: SListI row
1272− => NP (Aliased (Expression outer grp commons schemas params from)) row -- ^ row constructor
1273− -> Query (Join outer from) commons schemas params row -- ^ subquery
1274− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1275−rowLteAny = unsafeRowSubqueryExpression "<= ANY"
1276−
1277−-- | >>> printSQL $ true `gtAll` values_ (true `as` #foo)
1278−-- TRUE > ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1279−gtAll
1280− :: Expression outer grp commons schemas params from ty -- ^ expression
1281− -> Query (Join outer from) commons schemas params '[alias ::: ty] -- ^ subquery
1282− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1283−gtAll = unsafeSubqueryExpression "> ALL"
1284−
1285−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression outer grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1286−-- >>> printSQL $ myRow `rowGtAll` values_ myRow
1287−-- ROW(1, FALSE) > ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1288−rowGtAll
1289− :: SListI row
1290− => NP (Aliased (Expression outer grp commons schemas params from)) row -- ^ row constructor
1291− -> Query (Join outer from) commons schemas params row -- ^ subquery
1292− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1293−rowGtAll = unsafeRowSubqueryExpression "> ALL"
1294−
1295−-- | >>> printSQL $ true `gtAny` values_ (true `as` #foo)
1296−-- TRUE > ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1297−gtAny
1298− :: Expression outer grp commons schemas params from ty -- ^ expression
1299− -> Query (Join outer from) commons schemas params '[alias ::: ty] -- ^ subquery
1300− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1301−gtAny = unsafeSubqueryExpression "> ANY"
1302−
1303−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression outer grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1304−-- >>> printSQL $ myRow `rowGtAny` values_ myRow
1305−-- ROW(1, FALSE) > ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1306−rowGtAny
1307− :: SListI row
1308− => NP (Aliased (Expression outer grp commons schemas params from)) row -- ^ row constructor
1309− -> Query (Join outer from) commons schemas params row -- ^ subquery
1310− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1311−rowGtAny = unsafeRowSubqueryExpression "> ANY"
1312−
1313−-- | >>> printSQL $ true `gteAll` values_ (true `as` #foo)
1314−-- TRUE >= ALL (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1315−gteAll
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_
13161135 :: Expression outer grp commons schemas params from ty -- ^ expression
1317− -> Query (Join outer from) commons schemas params '[alias ::: ty] -- ^ subquery
1318− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1319−gteAll = unsafeSubqueryExpression ">= ALL"
1320−
1321−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression outer grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1322−-- >>> printSQL $ myRow `rowGteAll` values_ myRow
1323−-- ROW(1, FALSE) >= ALL (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1324−rowGteAll
1325− :: SListI row
1326− => NP (Aliased (Expression outer grp commons schemas params from)) row -- ^ row constructor
1327− -> Query (Join outer from) commons schemas params row -- ^ subquery
1328− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1329−rowGteAll = unsafeRowSubqueryExpression ">= ALL"
1330−
1331−-- | >>> printSQL $ true `gteAny` values_ (true `as` #foo)
1332−-- TRUE >= ANY (SELECT * FROM (VALUES (TRUE)) AS t ("foo"))
1333−gteAny
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)
1147+-}
1148+notIn
13341149 :: Expression outer grp commons schemas params from ty -- ^ expression
1335− -> Query (Join outer from) commons schemas params '[alias ::: ty] -- ^ subquery
1336− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1337−gteAny = unsafeSubqueryExpression ">= ANY"
1338−
1339−-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression outer grp commons schemas params from)) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]
1340−-- >>> printSQL $ myRow `rowGteAny` values_ myRow
1341−-- ROW(1, FALSE) >= ANY (SELECT * FROM (VALUES (1, FALSE)) AS t ("foo", "bar"))
1342−rowGteAny
1343− :: SListI row
1344− => NP (Aliased (Expression outer grp commons schemas params from)) row -- ^ row constructor
1345− -> Query (Join outer from) commons schemas params row -- ^ subquery
1346− -> Expression outer grp commons schemas params from (nullity 'PGbool)
1347−rowGteAny = unsafeRowSubqueryExpression ">= ANY"
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))
13481154
13491155-- | A `CommonTableExpression` is an auxiliary statement in a `with` clause.
13501156data CommonTableExpression statement