015d2c1 · squeal · git.iko.soy

1096 :: ByteString

1097 -> Expression schema from grp params ty

1098 -> Query schema params '[alias ::: ty]

1099− -> Condition schema from grp params

1099+ -> Expression schema from grp params (nullity 'PGbool)

1100unsafeSubqueryExpression op x q = UnsafeExpression $

1101 renderExpression x <+> op <+> parenthesized (renderQuery q)

1102

1105 => ByteString

1106 -> NP (Aliased (Expression schema from grp params)) row

1107 -> Query schema params row

1108− -> Condition schema from grp params

1108+ -> Expression schema from grp params (nullity 'PGbool)

1109unsafeRowSubqueryExpression op xs q = UnsafeExpression $

1110 renderExpression (row xs) <+> op <+> parenthesized (renderQuery q)

1111

1120in_

1121 :: Expression schema from grp params ty -- ^ expression

1122 -> Query schema params '[alias ::: ty] -- ^ subquery

1123− -> Condition schema from grp params

1123+ -> Expression schema from grp params (nullity 'PGbool)

1124in_ = unsafeSubqueryExpression "IN"

1125

1126{- | The left-hand side of this form of `rowIn` is a row constructor.

1141 :: SListI row

1142 => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor

1143 -> Query schema params row -- ^ subquery

1144− -> Condition schema from grp params

1144+ -> Expression schema from grp params (nullity 'PGbool)

1145rowIn = unsafeRowSubqueryExpression "IN"

1146

1147-- | >>> printSQL $ true `eqAll` values_ (true `as` #foo)

1149eqAll

1150 :: Expression schema from grp params ty -- ^ expression

1151 -> Query schema params '[alias ::: ty] -- ^ subquery

1152− -> Condition schema from grp params

1152+ -> Expression schema from grp params (nullity 'PGbool)

1153eqAll = unsafeSubqueryExpression "= ALL"

1154

1155-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]

1159 :: SListI row

1160 => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor

1161 -> Query schema params row -- ^ subquery

1162− -> Condition schema from grp params

1162+ -> Expression schema from grp params (nullity 'PGbool)

1163rowEqAll = unsafeRowSubqueryExpression "= ALL"

1164

1165-- | >>> printSQL $ true `eqAny` values_ (true `as` #foo)

1167eqAny

1168 :: Expression schema from grp params ty -- ^ expression

1169 -> Query schema params '[alias ::: ty] -- ^ subquery

1170− -> Condition schema from grp params

1170+ -> Expression schema from grp params (nullity 'PGbool)

1171eqAny = unsafeSubqueryExpression "= ANY"

1172

1173-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]

1177 :: SListI row

1178 => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor

1179 -> Query schema params row -- ^ subquery

1180− -> Condition schema from grp params

1180+ -> Expression schema from grp params (nullity 'PGbool)

1181rowEqAny = unsafeRowSubqueryExpression "= ANY"

1182

1183-- | >>> printSQL $ true `neqAll` values_ (true `as` #foo)

1185neqAll

1186 :: Expression schema from grp params ty -- ^ expression

1187 -> Query schema params '[alias ::: ty] -- ^ subquery

1188− -> Condition schema from grp params

1188+ -> Expression schema from grp params (nullity 'PGbool)

1189neqAll = unsafeSubqueryExpression "<> ALL"

1190

1191-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]

1195 :: SListI row

1196 => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor

1197 -> Query schema params row -- ^ subquery

1198− -> Condition schema from grp params

1198+ -> Expression schema from grp params (nullity 'PGbool)

1199rowNeqAll = unsafeRowSubqueryExpression "<> ALL"

1200

1201-- | >>> printSQL $ true `neqAny` values_ (true `as` #foo)

1203neqAny

1204 :: Expression schema from grp params ty -- ^ expression

1205 -> Query schema params '[alias ::: ty] -- ^ subquery

1206− -> Condition schema from grp params

1206+ -> Expression schema from grp params (nullity 'PGbool)

1207neqAny = unsafeSubqueryExpression "<> ANY"

1208

1209-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]

1213 :: SListI row

1214 => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor

1215 -> Query schema params row -- ^ subquery

1216− -> Condition schema from grp params

1216+ -> Expression schema from grp params (nullity 'PGbool)

1217rowNeqAny = unsafeRowSubqueryExpression "<> ANY"

1218

1219-- | >>> printSQL $ true `allLt` values_ (true `as` #foo)

1221allLt

1222 :: Expression schema from grp params ty -- ^ expression

1223 -> Query schema params '[alias ::: ty] -- ^ subquery

1224− -> Condition schema from grp params

1224+ -> Expression schema from grp params (nullity 'PGbool)

1225allLt = unsafeSubqueryExpression "ALL <"

1226

1227-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]

1231 :: SListI row

1232 => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor

1233 -> Query schema params row -- ^ subquery

1234− -> Condition schema from grp params

1234+ -> Expression schema from grp params (nullity 'PGbool)

1235rowLtAll = unsafeRowSubqueryExpression "ALL <"

1236

1237-- | >>> printSQL $ true `ltAny` values_ (true `as` #foo)

1239ltAny

1240 :: Expression schema from grp params ty -- ^ expression

1241 -> Query schema params '[alias ::: ty] -- ^ subquery

1242− -> Condition schema from grp params

1242+ -> Expression schema from grp params (nullity 'PGbool)

1243ltAny = unsafeSubqueryExpression "ANY <"

1244

1245-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]

1249 :: SListI row

1250 => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor

1251 -> Query schema params row -- ^ subquery

1252− -> Condition schema from grp params

1252+ -> Expression schema from grp params (nullity 'PGbool)

1253rowLtAny = unsafeRowSubqueryExpression "ANY <"

1254

1255-- | >>> printSQL $ true `lteAll` values_ (true `as` #foo)

1257lteAll

1258 :: Expression schema from grp params ty -- ^ expression

1259 -> Query schema params '[alias ::: ty] -- ^ subquery

1260− -> Condition schema from grp params

1260+ -> Expression schema from grp params (nullity 'PGbool)

1261lteAll = unsafeSubqueryExpression "<= ALL"

1262

1263-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]

1267 :: SListI row

1268 => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor

1269 -> Query schema params row -- ^ subquery

1270− -> Condition schema from grp params

1270+ -> Expression schema from grp params (nullity 'PGbool)

1271rowLteAll = unsafeRowSubqueryExpression "<= ALL"

1272

1273-- | >>> printSQL $ true `lteAny` values_ (true `as` #foo)

1275lteAny

1276 :: Expression schema from grp params ty -- ^ expression

1277 -> Query schema params '[alias ::: ty] -- ^ subquery

1278− -> Condition schema from grp params

1278+ -> Expression schema from grp params (nullity 'PGbool)

1279lteAny = unsafeSubqueryExpression "<= ANY"

1280

1281-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]

1285 :: SListI row

1286 => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor

1287 -> Query schema params row -- ^ subquery

1288− -> Condition schema from grp params

1288+ -> Expression schema from grp params (nullity 'PGbool)

1289rowLteAny = unsafeRowSubqueryExpression "<= ANY"

1290

1291-- | >>> printSQL $ true `gtAll` values_ (true `as` #foo)

1293gtAll

1294 :: Expression schema from grp params ty -- ^ expression

1295 -> Query schema params '[alias ::: ty] -- ^ subquery

1296− -> Condition schema from grp params

1296+ -> Expression schema from grp params (nullity 'PGbool)

1297gtAll = unsafeSubqueryExpression "> ALL"

1298

1299-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]

1303 :: SListI row

1304 => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor

1305 -> Query schema params row -- ^ subquery

1306− -> Condition schema from grp params

1306+ -> Expression schema from grp params (nullity 'PGbool)

1307rowGtAll = unsafeRowSubqueryExpression "> ALL"

1308

1309-- | >>> printSQL $ true `gtAny` values_ (true `as` #foo)

1311gtAny

1312 :: Expression schema from grp params ty -- ^ expression

1313 -> Query schema params '[alias ::: ty] -- ^ subquery

1314− -> Condition schema from grp params

1314+ -> Expression schema from grp params (nullity 'PGbool)

1315gtAny = unsafeSubqueryExpression "> ANY"

1316

1317-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]

1321 :: SListI row

1322 => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor

1323 -> Query schema params row -- ^ subquery

1324− -> Condition schema from grp params

1324+ -> Expression schema from grp params (nullity 'PGbool)

1325rowGtAny = unsafeRowSubqueryExpression "> ANY"

1326

1327-- | >>> printSQL $ true `gteAll` values_ (true `as` #foo)

1329gteAll

1330 :: Expression schema from grp params ty -- ^ expression

1331 -> Query schema params '[alias ::: ty] -- ^ subquery

1332− -> Condition schema from grp params

1332+ -> Expression schema from grp params (nullity 'PGbool)

1333gteAll = unsafeSubqueryExpression ">= ALL"

1334

1335-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]

1339 :: SListI row

1340 => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor

1341 -> Query schema params row -- ^ subquery

1342− -> Condition schema from grp params

1342+ -> Expression schema from grp params (nullity 'PGbool)

1343rowGteAll = unsafeRowSubqueryExpression ">= ALL"

1344

1345-- | >>> printSQL $ true `gteAny` values_ (true `as` #foo)

1347gteAny

1348 :: Expression schema from grp params ty -- ^ expression

1349 -> Query schema params '[alias ::: ty] -- ^ subquery

1350− -> Condition schema from grp params

1350+ -> Expression schema from grp params (nullity 'PGbool)

1351gteAny = unsafeSubqueryExpression ">= ANY"

1352

1353-- | >>> let myRow = 1 `as` #foo :* false `as` #bar :: NP (Aliased (Expression '[] '[] 'Ungrouped '[])) '["foo" ::: 'NotNull 'PGint2, "bar" ::: 'NotNull 'PGbool]

1357 :: SListI row

1358 => NP (Aliased (Expression schema from grp params)) row -- ^ row constructor

1359 -> Query schema params row -- ^ subquery

1360− -> Condition schema from grp params

1360+ -> Expression schema from grp params (nullity 'PGbool)

1361rowGteAny = unsafeRowSubqueryExpression ">= ANY"

1362

1363-- | A `CommonTableExpression` is an auxiliary statement in a `with` clause.