git.iko.soy/rel8
on master help sign in
Flip the argument order for statements
b95592eOllie Charles
src/Rel8/Statement/Delete.hs+4−5
compare with master
unifiedsplit
@@ -13,7 +13,6 @@ where
13
13
14-- base
14-- base
15import Control.Exception ( throwIO )
15import Control.Exception ( throwIO )
16−import Control.Monad ( (>=>) )
17import Data.Kind ( Type )
16import Data.Kind ( Type )
18import Prelude
17import Prelude
19
18
@@ -75,10 +74,10 @@ data Delete a where
75-- >>> mapM_ print =<< select c (each projectSchema)
74-- >>> mapM_ print =<< select c (each projectSchema)
76-- Project {projectAuthorId = 2, projectName = "aeson"}
75-- Project {projectAuthorId = 2, projectName = "aeson"}
77-- Project {projectAuthorId = 2, projectName = "text"}
76-- Project {projectAuthorId = 2, projectName = "text"}
78−delete :: Delete a -> Connection -> IO a
77+delete :: Connection -> Delete a -> IO a
79−delete Delete {from, deleteWhere, returning} =
78+delete c Delete {from, deleteWhere, returning} =
80 case returning of
79 case returning of
81− NumberOfRowsAffected -> Hasql.run session >=> either throwIO pure
80+ NumberOfRowsAffected -> Hasql.run session c >>= either throwIO pure
82 where
81 where
83 session = Hasql.statement () statement
82 session = Hasql.statement () statement
84 statement = Hasql.Statement bytes params decode prepare
83 statement = Hasql.Statement bytes params decode prepare
@@ -91,7 +90,7 @@ delete Delete {from, deleteWhere, returning} =
91 from' = table $ toColumns <$> from
90 from' = table $ toColumns <$> from
92 where' = toColumn . toPrimExpr . deleteWhere . fromColumns
91 where' = toColumn . toPrimExpr . deleteWhere . fromColumns
93
92
94− Projection project -> Hasql.run session >=> either throwIO pure
93+ Projection project -> Hasql.run session c >>= either throwIO pure
95 where
94 where
96 session = Hasql.statement () statement
95 session = Hasql.statement () statement
97 statement = Hasql.Statement bytes params decode prepare
96 statement = Hasql.Statement bytes params decode prepare
src/Rel8/Statement/Insert.hs+6−7
@@ -15,7 +15,6 @@ where
15
15
16-- base
16-- base
17import Control.Exception ( throwIO )
17import Control.Exception ( throwIO )
18−import Control.Monad ( (>=>) )
19import Data.Kind ( Type )
18import Data.Kind ( Type )
20import Data.List.NonEmpty ( NonEmpty( (:|) ) )
19import Data.List.NonEmpty ( NonEmpty( (:|) ) )
21import Prelude
20import Prelude
@@ -77,13 +76,13 @@ data OnConflict
77-- }
76-- }
78-- :}
77-- :}
79-- 1
78-- 1
80−insert :: Insert a -> Connection -> IO a
79+insert :: Connection -> Insert a -> IO a
81−insert Insert {into, rows, onConflict, returning} =
80+insert c Insert {into, rows, onConflict, returning} =
82 case (rows, returning) of
81 case (rows, returning) of
83− ([], NumberOfRowsAffected) -> const $ pure 0
82+ ([], NumberOfRowsAffected) -> pure 0
84− ([], Projection _) -> const $ pure []
83+ ([], Projection _) -> pure []
85
84
86− (x:xs, NumberOfRowsAffected) -> Hasql.run session >=> either throwIO pure
85+ (x:xs, NumberOfRowsAffected) -> Hasql.run session c >>= either throwIO pure
87 where
86 where
88 session = Hasql.statement () statement
87 session = Hasql.statement () statement
89 statement = Hasql.Statement bytes params decode prepare
88 statement = Hasql.Statement bytes params decode prepare
@@ -96,7 +95,7 @@ insert Insert {into, rows, onConflict, returning} =
96 into' = table $ toColumns <$> into
95 into' = table $ toColumns <$> into
97 rows' = toColumns <$> x :| xs
96 rows' = toColumns <$> x :| xs
98
97
99− (x:xs, Projection project) -> Hasql.run session >=> either throwIO pure
98+ (x:xs, Projection project) -> Hasql.run session c >>= either throwIO pure
100 where
99 where
101 session = Hasql.statement () statement
100 session = Hasql.statement () statement
102 statement = Hasql.Statement bytes params decode prepare
101 statement = Hasql.Statement bytes params decode prepare
src/Rel8/Statement/Select.hs+8−9
@@ -9,7 +9,6 @@ where
9
9
10-- base
10-- base
11import Control.Exception ( throwIO )
11import Control.Exception ( throwIO )
12−import Control.Monad ( (>=>) )
13import Prelude
12import Prelude
14
13
15-- hasql
14-- hasql
@@ -32,10 +31,10 @@ import Data.Text.Encoding ( encodeUtf8 )
32
31
33-- | Run a @SELECT@ query, returning all rows.
32-- | Run a @SELECT@ query, returning all rows.
34select :: forall exprs a. Serializable exprs a
33select :: forall exprs a. Serializable exprs a
35− => Query exprs -> Connection -> IO [a]
34+ => Connection -> Query exprs -> IO [a]
36−select query = case sqlForQuery query of
35+select c query = case sqlForQuery query of
37− Nothing -> const $ pure []
36+ Nothing -> pure []
38− Just sql -> Hasql.run session >=> either throwIO pure
37+ Just sql -> Hasql.run session c >>= either throwIO pure
39 where
38 where
40 session = Hasql.statement () statement
39 session = Hasql.statement () statement
41 statement = Hasql.Statement bytes params decode prepare
40 statement = Hasql.Statement bytes params decode prepare
@@ -49,10 +48,10 @@ selectWithNames :: forall exprs a names.
49 ( Selects names exprs
48 ( Selects names exprs
50 , Serializable exprs a
49 , Serializable exprs a
51 )
50 )
52− => names -> Query exprs -> Connection -> IO [a]
51+ => Connection -> names -> Query exprs -> IO [a]
53−selectWithNames names query = case sqlForQueryWithNames names query of
52+selectWithNames c names query = case sqlForQueryWithNames names query of
54− Nothing -> const $ pure []
53+ Nothing -> pure []
55− Just sql -> Hasql.run session >=> either throwIO pure
54+ Just sql -> Hasql.run session c >>= either throwIO pure
56 where
55 where
57 session = Hasql.statement () statement
56 session = Hasql.statement () statement
58 statement = Hasql.Statement bytes params decode prepare
57 statement = Hasql.Statement bytes params decode prepare
src/Rel8/Statement/Update.hs+4−5
@@ -12,7 +12,6 @@ where
12
12
13-- base
13-- base
14import Control.Exception ( throwIO )
14import Control.Exception ( throwIO )
15−import Control.Monad ( (>=>) )
16import Data.Kind ( Type )
15import Data.Kind ( Type )
17import Prelude
16import Prelude
18
17
@@ -82,10 +81,10 @@ data Update a where
82-- Project {projectAuthorId = 2, projectName = "aeson"}
81-- Project {projectAuthorId = 2, projectName = "aeson"}
83-- Project {projectAuthorId = 2, projectName = "text"}
82-- Project {projectAuthorId = 2, projectName = "text"}
84-- Project {projectAuthorId = 1, projectName = "Rel8!"}
83-- Project {projectAuthorId = 1, projectName = "Rel8!"}
85−update :: Update a -> Connection -> IO a
84+update :: Connection -> Update a -> IO a
86−update Update {target, set, updateWhere, returning} =
85+update c Update {target, set, updateWhere, returning} =
87 case returning of
86 case returning of
88− NumberOfRowsAffected -> Hasql.run session >=> either throwIO pure
87+ NumberOfRowsAffected -> Hasql.run session c >>= either throwIO pure
89 where
88 where
90 session = Hasql.statement () statement
89 session = Hasql.statement () statement
91 statement = Hasql.Statement bytes params decode prepare
90 statement = Hasql.Statement bytes params decode prepare
@@ -99,7 +98,7 @@ update Update {target, set, updateWhere, returning} =
99 set' = toColumns . set . fromColumns
98 set' = toColumns . set . fromColumns
100 where' = toColumn . toPrimExpr . updateWhere . fromColumns
99 where' = toColumn . toPrimExpr . updateWhere . fromColumns
101
100
102− Projection project -> Hasql.run session >=> either throwIO pure
101+ Projection project -> Hasql.run session c >>= either throwIO pure
103 where
102 where
104 session = Hasql.statement () statement
103 session = Hasql.statement () statement
105 statement = Hasql.Statement bytes params decode prepare
104 statement = Hasql.Statement bytes params decode prepare
tests/Main.hs+33−37
@@ -214,7 +214,7 @@ testSelectTestTable = databasePropertyTest "Can SELECT TestTable" \transaction -
214
214
215 transaction \connection -> do
215 transaction \connection -> do
216 void do
216 void do
217− testing Rel8.insert connection
217+ liftIO $ Rel8.insert connection
218 Rel8.Insert
218 Rel8.Insert
219 { into = testTableSchema
219 { into = testTableSchema
220 , rows = map (Rel8.toInsert . Rel8.lit) rows
220 , rows = map (Rel8.toInsert . Rel8.lit) rows
@@ -222,7 +222,7 @@ testSelectTestTable = databasePropertyTest "Can SELECT TestTable" \transaction -
222 , returning = Rel8.NumberOfRowsAffected
222 , returning = Rel8.NumberOfRowsAffected
223 }
223 }
224
224
225− selected <- testing Rel8.select connection do
225+ selected <- liftIO $ Rel8.select connection do
226 Rel8.each testTableSchema
226 Rel8.each testTableSchema
227
227
228 sort selected === sort rows
228 sort selected === sort rows
@@ -241,7 +241,7 @@ testWhere_ = databasePropertyTest "WHERE (Rel8.where_)" \transaction -> do
241 let expected = filter (\t -> testTableColumn2 t == magicBool) rows
241 let expected = filter (\t -> testTableColumn2 t == magicBool) rows
242
242
243 transaction \connection -> do
243 transaction \connection -> do
244− selected <- testing Rel8.select connection do
244+ selected <- liftIO $ Rel8.select connection do
245 t <- Rel8.values $ Rel8.lit <$> rows
245 t <- Rel8.values $ Rel8.lit <$> rows
246 Rel8.where_ $ testTableColumn2 t Rel8.==. Rel8.lit magicBool
246 Rel8.where_ $ testTableColumn2 t Rel8.==. Rel8.lit magicBool
247 return t
247 return t
@@ -260,7 +260,7 @@ testFilter = databasePropertyTest "filter" \transaction -> do
260 transaction \connection -> do
260 transaction \connection -> do
261 let expected = filter testTableColumn2 rows
261 let expected = filter testTableColumn2 rows
262
262
263− selected <- testing Rel8.select connection
263+ selected <- liftIO $ Rel8.select connection
264 $ Rel8.filter testTableColumn2 =<< Rel8.values (Rel8.lit <$> rows)
264 $ Rel8.filter testTableColumn2 =<< Rel8.values (Rel8.lit <$> rows)
265
265
266 sort selected === sort expected
266 sort selected === sort expected
@@ -277,7 +277,7 @@ testLimit = databasePropertyTest "LIMIT (Rel8.limit)" \transaction -> do
277 n <- forAll $ Gen.integral (Range.linear 0 10)
277 n <- forAll $ Gen.integral (Range.linear 0 10)
278
278
279 transaction \connection -> do
279 transaction \connection -> do
280− selected <- testing Rel8.select connection do
280+ selected <- liftIO $ Rel8.select connection do
281 Rel8.limit n $ Rel8.values (Rel8.lit <$> rows)
281 Rel8.limit n $ Rel8.values (Rel8.lit <$> rows)
282
282
283 diff (length selected) (<=) (fromIntegral n)
283 diff (length selected) (<=) (fromIntegral n)
@@ -297,7 +297,7 @@ testUnion = databasePropertyTest "UNION (Rel8.union)" \transaction -> evalM do
297 right <- forAll $ Gen.list (Range.linear 0 10) genTestTable
297 right <- forAll $ Gen.list (Range.linear 0 10) genTestTable
298
298
299 transaction \connection -> do
299 transaction \connection -> do
300− selected <- testing Rel8.select connection do
300+ selected <- liftIO $ Rel8.select connection do
301 Rel8.values (Rel8.lit <$> nub left) `Rel8.union` Rel8.values (Rel8.lit <$> nub right)
301 Rel8.values (Rel8.lit <$> nub left) `Rel8.union` Rel8.values (Rel8.lit <$> nub right)
302
302
303 sort selected === sort (nub (left ++ right))
303 sort selected === sort (nub (left ++ right))
@@ -308,7 +308,7 @@ testDistinct = databasePropertyTest "DISTINCT (Rel8.distinct)" \transaction -> d
308 rows <- forAll $ Gen.list (Range.linear 0 10) genTestTable
308 rows <- forAll $ Gen.list (Range.linear 0 10) genTestTable
309
309
310 transaction \connection -> do
310 transaction \connection -> do
311− selected <- testing Rel8.select connection $ Rel8.distinct do
311+ selected <- liftIO $ Rel8.select connection $ Rel8.distinct do
312 Rel8.values (Rel8.lit <$> rows)
312 Rel8.values (Rel8.lit <$> rows)
313
313
314 sort selected === nub (sort rows)
314 sort selected === nub (sort rows)
@@ -323,7 +323,7 @@ testExists = databasePropertyTest "EXISTS (Rel8.exists)" \transaction -> do
323 rows <- forAll $ Gen.list (Range.linear 0 10) genTestTable
323 rows <- forAll $ Gen.list (Range.linear 0 10) genTestTable
324
324
325 transaction \connection -> do
325 transaction \connection -> do
326− exists <- testing Rel8.select connection $ Rel8.exists $ Rel8.values $ Rel8.lit <$> rows
326+ exists <- liftIO $ Rel8.select connection $ Rel8.exists $ Rel8.values $ Rel8.lit <$> rows
327
327
328 case rows of
328 case rows of
329 [] -> exists === [False]
329 [] -> exists === [False]
@@ -335,7 +335,7 @@ testOptional = databasePropertyTest "Rel8.optional" \transaction -> do
335 rows <- forAll $ Gen.list (Range.linear 0 10) genTestTable
335 rows <- forAll $ Gen.list (Range.linear 0 10) genTestTable
336
336
337 transaction \connection -> do
337 transaction \connection -> do
338− selected <- testing Rel8.select connection do
338+ selected <- liftIO $ Rel8.select connection do
339 Rel8.optional $ Rel8.values (Rel8.lit <$> rows)
339 Rel8.optional $ Rel8.values (Rel8.lit <$> rows)
340
340
341 case rows of
341 case rows of
@@ -348,7 +348,7 @@ testAnd = databasePropertyTest "AND (&&.)" \transaction -> do
348 (x, y) <- forAll $ liftA2 (,) Gen.bool Gen.bool
348 (x, y) <- forAll $ liftA2 (,) Gen.bool Gen.bool
349
349
350 transaction \connection -> do
350 transaction \connection -> do
351− [result] <- testing Rel8.select connection $ pure $
351+ [result] <- liftIO $ Rel8.select connection $ pure $
352 Rel8.lit x Rel8.&&. Rel8.lit y
352 Rel8.lit x Rel8.&&. Rel8.lit y
353
353
354 result === (x && y)
354 result === (x && y)
@@ -359,7 +359,7 @@ testOr = databasePropertyTest "OR (||.)" \transaction -> do
359 (x, y) <- forAll $ liftA2 (,) Gen.bool Gen.bool
359 (x, y) <- forAll $ liftA2 (,) Gen.bool Gen.bool
360
360
361 transaction \connection -> do
361 transaction \connection -> do
362− [result] <- testing Rel8.select connection $ pure $
362+ [result] <- liftIO $ Rel8.select connection $ pure $
363 Rel8.lit x Rel8.||. Rel8.lit y
363 Rel8.lit x Rel8.||. Rel8.lit y
364
364
365 result === (x || y)
365 result === (x || y)
@@ -370,7 +370,7 @@ testLogicalFixities = databasePropertyTest "Logical operator fixities" \transact
370 (u, v, w, x) <- forAll $ (,,,) <$> Gen.bool <*> Gen.bool <*> Gen.bool <*> Gen.bool
370 (u, v, w, x) <- forAll $ (,,,) <$> Gen.bool <*> Gen.bool <*> Gen.bool <*> Gen.bool
371
371
372 transaction \connection -> do
372 transaction \connection -> do
373− [result] <- testing Rel8.select connection $ pure $
373+ [result] <- liftIO $ Rel8.select connection $ pure $
374 Rel8.lit u Rel8.||. Rel8.lit v Rel8.&&. Rel8.lit w Rel8.==. Rel8.lit x
374 Rel8.lit u Rel8.||. Rel8.lit v Rel8.&&. Rel8.lit w Rel8.==. Rel8.lit x
375
375
376 result === (u || v && w == x)
376 result === (u || v && w == x)
@@ -381,7 +381,7 @@ testNot = databasePropertyTest "NOT (not_)" \transaction -> do
381 x <- forAll Gen.bool
381 x <- forAll Gen.bool
382
382
383 transaction \connection -> do
383 transaction \connection -> do
384− [result] <- testing Rel8.select connection $ pure $
384+ [result] <- liftIO $ Rel8.select connection $ pure $
385 Rel8.not_ $ Rel8.lit x
385 Rel8.not_ $ Rel8.lit x
386
386
387 result === not x
387 result === not x
@@ -392,7 +392,7 @@ testBool = databasePropertyTest "ifThenElse_" \transaction -> do
392 (x, y, z) <- forAll $ liftA3 (,,) Gen.bool Gen.bool Gen.bool
392 (x, y, z) <- forAll $ liftA3 (,,) Gen.bool Gen.bool Gen.bool
393
393
394 transaction \connection -> do
394 transaction \connection -> do
395− [result] <- testing Rel8.select connection $ pure $
395+ [result] <- liftIO $ Rel8.select connection $ pure $
396 Rel8.bool (Rel8.lit z) (Rel8.lit y) (Rel8.lit x)
396 Rel8.bool (Rel8.lit z) (Rel8.lit y) (Rel8.lit x)
397
397
398 result === if x then y else z
398 result === if x then y else z
@@ -406,7 +406,7 @@ testAp = databasePropertyTest "Cartesian product (<*>)" \transaction -> do
406 (Gen.list (Range.linear 1 10) genTestTable)
406 (Gen.list (Range.linear 1 10) genTestTable)
407
407
408 transaction \connection -> do
408 transaction \connection -> do
409− result <- testing Rel8.select connection $ do
409+ result <- liftIO $ Rel8.select connection $ do
410 liftA2 (,) (Rel8.values (Rel8.lit <$> rows1)) (Rel8.values (Rel8.lit <$> rows2))
410 liftA2 (,) (Rel8.values (Rel8.lit <$> rows1)) (Rel8.values (Rel8.lit <$> rows2))
411
411
412 sort result === sort (liftA2 (,) rows1 rows2)
412 sort result === sort (liftA2 (,) rows1 rows2)
@@ -455,7 +455,7 @@ testDBType getTestDatabase = testGroup "DBType instances"
455 x <- forAll generator
455 x <- forAll generator
456
456
457 transaction \connection -> do
457 transaction \connection -> do
458− [res] <- testing Rel8.select connection $ pure (Rel8.lit x :: Rel8.Expr a)
458+ [res] <- liftIO $ Rel8.select connection $ pure (Rel8.lit x :: Rel8.Expr a)
459 diff res eq x
459 diff res eq x
460
460
461 genDay :: Gen Day
461 genDay :: Gen Day
@@ -514,7 +514,7 @@ testDBEq getTestDatabase = testGroup "DBEq instances"
514 (x, y) <- forAll (liftA2 (,) generator generator)
514 (x, y) <- forAll (liftA2 (,) generator generator)
515
515
516 transaction \connection -> do
516 transaction \connection -> do
517− [res] <- testing Rel8.select connection $ pure $ Rel8.lit @(Rel8.Expr a) x Rel8.==. Rel8.lit y
517+ [res] <- liftIO $ Rel8.select connection $ pure $ Rel8.lit @(Rel8.Expr a) x Rel8.==. Rel8.lit y
518 res === (x == y)
518 res === (x == y)
519
519
520 cover 1 "Equal" $ x == y
520 cover 1 "Equal" $ x == y
@@ -526,7 +526,7 @@ testTableEquality = databasePropertyTest "TestTable equality" \transaction -> do
526 (x, y) <- forAll $ liftA2 (,) genTestTable genTestTable
526 (x, y) <- forAll $ liftA2 (,) genTestTable genTestTable
527
527
528 transaction \connection -> do
528 transaction \connection -> do
529− [eq] <- testing Rel8.select connection do
529+ [eq] <- liftIO $ Rel8.select connection do
530 pure $ Rel8.lit x Rel8.==: Rel8.lit y
530 pure $ Rel8.lit x Rel8.==: Rel8.lit y
531
531
532 eq === (x == y)
532 eq === (x == y)
@@ -540,7 +540,7 @@ testFromString = databasePropertyTest "FromString" \transaction -> do
540 str <- forAll $ Gen.list (Range.linear 0 10) Gen.unicode
540 str <- forAll $ Gen.list (Range.linear 0 10) Gen.unicode
541
541
542 transaction \connection -> do
542 transaction \connection -> do
543− [result] <- testing Rel8.select connection $ pure $ fromString str
543+ [result] <- liftIO $ Rel8.select connection $ pure $ fromString str
544 result === pack str
544 result === pack str
545
545
546
546
@@ -549,7 +549,7 @@ testCatMaybeTable = databasePropertyTest "catMaybeTable" \transaction -> do
549 rows <- forAll $ Gen.list (Range.linear 0 10) genTestTable
549 rows <- forAll $ Gen.list (Range.linear 0 10) genTestTable
550
550
551 transaction \connection -> do
551 transaction \connection -> do
552− selected <- testing Rel8.select connection do
552+ selected <- liftIO $ Rel8.select connection do
553 testTable <- Rel8.values $ Rel8.lit <$> rows
553 testTable <- Rel8.values $ Rel8.lit <$> rows
554 Rel8.catMaybeTable $ Rel8.bool Rel8.nothingTable (pure testTable) (testTableColumn2 testTable)
554 Rel8.catMaybeTable $ Rel8.bool Rel8.nothingTable (pure testTable) (testTableColumn2 testTable)
555
555
@@ -561,7 +561,7 @@ testCatMaybe = databasePropertyTest "catMaybe" \transaction -> evalM do
561 rows <- forAll $ Gen.list (Range.linear 0 10) $ Gen.maybe Gen.bool
561 rows <- forAll $ Gen.list (Range.linear 0 10) $ Gen.maybe Gen.bool
562
562
563 transaction \connection -> do
563 transaction \connection -> do
564− selected <- evalM $ testing Rel8.select connection do
564+ selected <- evalM $ liftIO $ Rel8.select connection do
565 Rel8.catNullable =<< Rel8.values (map Rel8.lit rows)
565 Rel8.catNullable =<< Rel8.values (map Rel8.lit rows)
566
566
567 sort selected === sort (catMaybes rows)
567 sort selected === sort (catMaybes rows)
@@ -572,7 +572,7 @@ testMaybeTable = databasePropertyTest "maybeTable" \transaction -> evalM do
572 (rows, def) <- forAll $ liftA2 (,) (Gen.list (Range.linear 0 10) genTestTable) genTestTable
572 (rows, def) <- forAll $ liftA2 (,) (Gen.list (Range.linear 0 10) genTestTable) genTestTable
573
573
574 transaction \connection -> do
574 transaction \connection -> do
575− selected <- testing Rel8.select connection $
575+ selected <- liftIO $ Rel8.select connection $
576 Rel8.maybeTable (Rel8.lit def) id <$> Rel8.optional (Rel8.values (Rel8.lit <$> rows))
576 Rel8.maybeTable (Rel8.lit def) id <$> Rel8.optional (Rel8.values (Rel8.lit <$> rows))
577
577
578 case rows of
578 case rows of
@@ -601,7 +601,7 @@ testNestedTables = databasePropertyTest "Nested TestTables" \transaction -> eval
601 liftA2 TwoTestTables genTestTable genTestTable
601 liftA2 TwoTestTables genTestTable genTestTable
602
602
603 transaction \connection -> do
603 transaction \connection -> do
604− selected <- testing Rel8.select connection do
604+ selected <- liftIO $ Rel8.select connection do
605 Rel8.values (Rel8.lit <$> rows)
605 Rel8.values (Rel8.lit <$> rows)
606
606
607 sort selected === sort rows
607 sort selected === sort rows
@@ -613,7 +613,7 @@ testMaybeTableApplicative = databasePropertyTest "MaybeTable (<*>)" \transaction
613 rows2 <- genRows
613 rows2 <- genRows
614
614
615 transaction \connection -> do
615 transaction \connection -> do
616− selected <- testing Rel8.select connection do
616+ selected <- liftIO $ Rel8.select connection do
617 as <- Rel8.optional (Rel8.values (Rel8.lit <$> rows1))
617 as <- Rel8.optional (Rel8.values (Rel8.lit <$> rows1))
618 bs <- Rel8.optional (Rel8.values (Rel8.lit <$> rows2))
618 bs <- Rel8.optional (Rel8.values (Rel8.lit <$> rows2))
619 pure $ liftA2 (,) as bs
619 pure $ liftA2 (,) as bs
@@ -649,7 +649,7 @@ testUpdate = databasePropertyTest "Can UPDATE TestTable" \transaction -> do
649 rows <- forAll $ Gen.map (Range.linear 0 5) $ liftA2 (,) genTestTable genTestTable
649 rows <- forAll $ Gen.map (Range.linear 0 5) $ liftA2 (,) genTestTable genTestTable
650
650
651 transaction \connection -> do
651 transaction \connection -> do
652− void $ testing Rel8.insert connection
652+ void $ liftIO $ Rel8.insert connection
653 Rel8.Insert
653 Rel8.Insert
654 { into = testTableSchema
654 { into = testTableSchema
655 , rows = map (Rel8.toInsert . Rel8.lit) $ Map.keys rows
655 , rows = map (Rel8.toInsert . Rel8.lit) $ Map.keys rows
@@ -657,7 +657,7 @@ testUpdate = databasePropertyTest "Can UPDATE TestTable" \transaction -> do
657 , returning = Rel8.NumberOfRowsAffected
657 , returning = Rel8.NumberOfRowsAffected
658 }
658 }
659
659
660− void $ testing Rel8.update connection
660+ void $ liftIO $ Rel8.update connection
661 Rel8.Update
661 Rel8.Update
662 { target = testTableSchema
662 { target = testTableSchema
663 , set = \r ->
663 , set = \r ->
@@ -678,7 +678,7 @@ testUpdate = databasePropertyTest "Can UPDATE TestTable" \transaction -> do
678 , returning = Rel8.NumberOfRowsAffected
678 , returning = Rel8.NumberOfRowsAffected
679 }
679 }
680
680
681− selected <- testing Rel8.select connection do
681+ selected <- liftIO $ Rel8.select connection do
682 Rel8.each testTableSchema
682 Rel8.each testTableSchema
683
683
684 sort selected === sort (Map.elems rows)
684 sort selected === sort (Map.elems rows)
@@ -693,7 +693,7 @@ testDelete = databasePropertyTest "Can DELETE TestTable" \transaction -> do
693 rows <- forAll $ Gen.list (Range.linear 0 5) genTestTable
693 rows <- forAll $ Gen.list (Range.linear 0 5) genTestTable
694
694
695 transaction \connection -> do
695 transaction \connection -> do
696− void $ testing Rel8.insert connection
696+ void $ liftIO $ Rel8.insert connection
697 Rel8.Insert
697 Rel8.Insert
698 { into = testTableSchema
698 { into = testTableSchema
699 , rows = map (Rel8.toInsert . Rel8.lit) rows
699 , rows = map (Rel8.toInsert . Rel8.lit) rows
@@ -702,14 +702,14 @@ testDelete = databasePropertyTest "Can DELETE TestTable" \transaction -> do
702 }
702 }
703
703
704 deleted <-
704 deleted <-
705− testing Rel8.delete connection
705+ liftIO $ Rel8.delete connection
706 Rel8.Delete
706 Rel8.Delete
707 { from = testTableSchema
707 { from = testTableSchema
708 , deleteWhere = testTableColumn2
708 , deleteWhere = testTableColumn2
709 , returning = Rel8.Projection id
709 , returning = Rel8.Projection id
710 }
710 }
711
711
712− selected <- testing Rel8.select connection do
712+ selected <- liftIO $ Rel8.select connection do
713 Rel8.each testTableSchema
713 Rel8.each testTableSchema
714
714
715 sort (deleted <> selected) === sort rows
715 sort (deleted <> selected) === sort rows
@@ -729,7 +729,7 @@ testSelectNestedPairs = databasePropertyTest "Can SELECT nested pairs" \transact
729 rows <- forAll $ Gen.list (Range.linear 0 10) $ HKNestedPair <$> liftA2 (,) genTestTable genTestTable
729 rows <- forAll $ Gen.list (Range.linear 0 10) $ HKNestedPair <$> liftA2 (,) genTestTable genTestTable
730
730
731 transaction \connection -> do
731 transaction \connection -> do
732− selected <- testing Rel8.select connection do
732+ selected <- liftIO $ Rel8.select connection do
733 Rel8.values $ map Rel8.lit rows
733 Rel8.values $ map Rel8.lit rows
734
734
735 sort selected === sort rows
735 sort selected === sort rows
@@ -740,7 +740,7 @@ testSelectArray = databasePropertyTest "Can SELECT Arrays (with aggregation)" \t
740 rows <- forAll $ Gen.list (Range.linear 1 10) Gen.bool
740 rows <- forAll $ Gen.list (Range.linear 1 10) Gen.bool
741
741
742 transaction \connection -> do
742 transaction \connection -> do
743− selected <- testing Rel8.select connection $ Rel8.aggregate do
743+ selected <- liftIO $ Rel8.select connection $ Rel8.aggregate do
744 Rel8.listAgg <$> Rel8.values (map Rel8.lit rows)
744 Rel8.listAgg <$> Rel8.values (map Rel8.lit rows)
745
745
746 selected === [foldMap pure rows]
746 selected === [foldMap pure rows]
@@ -764,12 +764,8 @@ testNestedMaybeTable = databasePropertyTest "Can nest MaybeTable within other ta
764 let example = NestedMaybeTable { nmt1 = True, nmt2 = Just (TestTable "Hi" True) }
764 let example = NestedMaybeTable { nmt1 = True, nmt2 = Just (TestTable "Hi" True) }
765
765
766 transaction \connection -> do
766 transaction \connection -> do
767− selected <- testing Rel8.select connection do
767+ selected <- liftIO $ Rel8.select connection do
768 x <- Rel8.values [Rel8.lit example]
768 x <- Rel8.values [Rel8.lit example]
769 pure $ Rel8.maybeTable (Rel8.lit False) (\_ -> Rel8.lit True) (nmt2 x)
769 pure $ Rel8.maybeTable (Rel8.lit False) (\_ -> Rel8.lit True) (nmt2 x)
770
770
771 selected === [True]
771 selected === [True]
772−
773−
774−testing :: MonadIO m => (a -> Connection -> IO b) -> Connection -> a -> m b
775−testing f connection a = liftIO $ f a connection