flake.lock

@@ -1,59 +1,23 @@
 {
   "nodes": {
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1731533236,
-        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1752536923,
-        "narHash": "sha256-fdgPZR7VFSSRIQKOJLcs3qCJBWM64Uak0gAGtWTYAd8=",
-        "owner": "nixos",
+        "lastModified": 1719285171,
+        "narHash": "sha256-kOUKtKfYEh8h8goL/P6lKF4Jb0sXnEkFyEganzdTGvo=",
+        "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "c665e4d918eda5d78a175ed8d300809c44932160",
+        "rev": "cfb89a95f19bea461fc37228dc4d07b22fe617c2",
         "type": "github"
       },
       "original": {
-        "owner": "nixos",
-        "ref": "release-25.05",
-        "repo": "nixpkgs",
-        "type": "github"
+        "id": "nixpkgs",
+        "type": "indirect"
       }
     },
     "root": {
       "inputs": {
-        "flake-utils": "flake-utils",
         "nixpkgs": "nixpkgs"
       }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
     }
   },
   "root": "root",

flake.nix

@@ -1,12 +1,10 @@
 {
   description = "An opionated Postgres library";
 
-  inputs.nixpkgs.url = "github:nixos/nixpkgs/release-25.05";
-  inputs.flake-utils.url = "github:numtide/flake-utils";
-
-  outputs = { self, nixpkgs, flake-utils }: flake-utils.lib.eachDefaultSystem (system:
+  outputs = { self, nixpkgs }:
     let
-      pkgs = import nixpkgs { inherit system; };
+      system = "aarch64-darwin";
+      pkgs = nixpkgs.legacyPackages.${system};
       opium = pkgs.haskellPackages.developPackage {
         root = ./.;
         modifier = drv:
@@ -17,13 +15,12 @@
           ];
       };
     in {
-      packages.opium = pkgs.haskell.lib.overrideCabal opium {
+      packages.${system}.opium = pkgs.haskell.lib.overrideCabal opium {
         # Currently the tests require a running Postgres instance.
         # This is not automated yet, so don't export the tests.
         doCheck = false;
       };
 
-      devShells.default = opium.env;
-    }
-  );
+      devShells.${system}.default = opium.env;
+    };
 }

lib/Database/PostgreSQL/Opium.hs

@@ -1,20 +1,16 @@
+{-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE TypeApplications #-}
 
 module Database.PostgreSQL.Opium
-    -- * Connection Management
-  ( Connection
-  , ConnectionError (..)
-  , connect
-  , close
     -- * Queries
     --
     -- Functions for performing queries. @fetch@ retrieves rows, @execute@ doesn't.
     -- The 'Connection' parameter comes last to facilitate currying for implicitly passing in the connection, e.g. from some framework's connection pool.
     --
     -- | TODO: Add @newtype Query = Query Text@ with @IsString@ instance to make constructing query strings at run time harder.
-  , fetch
+  ( fetch
   , fetch_
   , execute
   , execute_
@@ -32,16 +28,18 @@ module Database.PostgreSQL.Opium
 
 import Control.Monad (unless, void)
 import Control.Monad.IO.Class (liftIO)
-import Control.Monad.Trans.Except (ExceptT (..), runExceptT, throwE)
+import Control.Monad.Trans.Except (ExceptT (..), except, runExceptT, throwE)
 import Data.Functor.Identity (Identity (..))
 import Data.Proxy (Proxy (..))
 import Data.Text (Text)
-import Database.PostgreSQL.LibPQ (Result)
+import Database.PostgreSQL.LibPQ
+  ( Connection
+  , Result
+  )
 
 import qualified Data.Text.Encoding as Encoding
 import qualified Database.PostgreSQL.LibPQ as LibPQ
 
-import Database.PostgreSQL.Opium.Connection (Connection, ConnectionError (..), connect, close, withRawConnection)
 import Database.PostgreSQL.Opium.Error (Error (..), ErrorPosition (..))
 import Database.PostgreSQL.Opium.FromField (FromField (..), RawField (..))
 import Database.PostgreSQL.Opium.FromRow (FromRow (..), ColumnTable)
@@ -59,11 +57,11 @@ instance RowContainer Maybe where
   extract result nRows columnTable
     | nRows == 0 = pure Nothing
     | nRows == 1 = Just <$> ExceptT (fromRow result columnTable 0)
-    | otherwise = throwE $ ErrorMoreThanOneRow $ fromEnum nRows
+    | otherwise = throwE ErrorMoreThanOneRow
 
 instance RowContainer Identity where
   extract result nRows columnTable = do
-    unless (nRows == 1) $ throwE $ ErrorNotExactlyOneRow $ fromEnum nRows
+    unless (nRows == 1) $ throwE ErrorNotExactlyOneRow
     Identity <$> ExceptT (fromRow result columnTable 0)
 
 -- The order of the type parameters is important, because it is more common to use type applications for providing the row type and row container type.
@@ -100,23 +98,14 @@ execParams
   -> a
   -> ExceptT Error IO Result
 execParams conn query params = do
-  -- Actually run the query while locking the connection.
-  mbResult <- ExceptT runQuery
-  -- Check whether the result is valid or nah.
-  result <- mbResult `orThrow` ErrorNoResult
-  status <- liftIO $ LibPQ.resultStatus result
-  mbMessage <- liftIO $ LibPQ.resultErrorMessage result
-  case mbMessage of
-    Just "" -> pure result
-    Nothing -> pure result
-    Just message -> throwE $ ErrorInvalidResult status $ Encoding.decodeUtf8 message
-
-  where
-    orThrow (Just x) _ = pure x
-    orThrow Nothing  e = throwE e
-
-    queryBytes = Encoding.encodeUtf8 query
-    runQuery =
-      flip withRawConnection conn $ \mbRawConn -> runExceptT $ do
-        rawConn <- mbRawConn `orThrow` ErrorConnectionClosed
-        liftIO $ LibPQ.execParams rawConn queryBytes (toParamList params) LibPQ.Binary
+  let queryBytes = Encoding.encodeUtf8 query
+  liftIO (LibPQ.execParams conn queryBytes (toParamList params) LibPQ.Binary) >>= \case
+    Nothing ->
+      except $ Left ErrorNoResult
+    Just result -> do
+      status <- liftIO $ LibPQ.resultStatus result
+      mbMessage <- liftIO $ LibPQ.resultErrorMessage result
+      case mbMessage of
+        Just "" -> pure result
+        Nothing -> pure result
+        Just message -> except $ Left $ ErrorInvalidResult status $ Encoding.decodeUtf8 message

lib/Database/PostgreSQL/Opium/Connection.hs

@@ -1,68 +0,0 @@
-{-# LANGUAGE LambdaCase #-}
-{-# LANGUAGE OverloadedRecordDot #-}
-{-# LANGUAGE OverloadedStrings #-}
-
-module Database.PostgreSQL.Opium.Connection
-  ( Connection
-  , ConnectionError (..)
-  , unsafeWithRawConnection
-  , withRawConnection
-  , connect
-  , close
-  ) where
-
-import Control.Concurrent.MVar (MVar, newMVar, modifyMVar_, withMVar)
-import Control.Exception (Exception)
-import Data.Maybe (fromMaybe)
-import Data.Text (Text)
-import Database.PostgreSQL.LibPQ (ConnStatus (..))
-import GHC.Stack (HasCallStack)
-
-import qualified Data.Text.Encoding as Encoding
-import qualified Database.PostgreSQL.LibPQ as LibPQ
-
-newtype Connection = Connection
-  { rawConnection :: MVar (Maybe LibPQ.Connection)
-  }
-
-newtype ConnectionError = ConnectionError Text
-  deriving (Show)
-
-instance Exception ConnectionError
-
-withRawConnection
-  :: HasCallStack
-  => (Maybe LibPQ.Connection -> IO a)
-  -> Connection
-  -> IO a
-withRawConnection f conn = withMVar conn.rawConnection f
-
-unsafeWithRawConnection
-  :: HasCallStack
-  => (LibPQ.Connection -> IO a)
-  -> Connection
-  -> IO a
-unsafeWithRawConnection f = withRawConnection $ \case
-  Nothing -> error "raw connection is missing! perhaps the connection was already closed."
-  Just rawConn -> f rawConn
-
-connect :: Text -> IO (Either ConnectionError Connection)
-connect connectionString = do
-  -- Appending the client_encoding setting overrides any previous setting in the connection string.
-  -- We set the client encoding here to make sure we can use it below for decoding connection
-  -- error messages.
-  rawConn <- LibPQ.connectdb $ Encoding.encodeUtf8 $ connectionString <> " client_encoding=UTF8"
-  status <- LibPQ.status rawConn
-  if status == ConnectionOk then
-    Right . Connection <$> newMVar (Just rawConn)
-  else do
-    rawError <- fromMaybe "" <$> LibPQ.errorMessage rawConn
-    pure $ Left $ ConnectionError $ Encoding.decodeUtf8Lenient rawError
-
-close :: Connection -> IO ()
-close conn = modifyMVar_ conn.rawConnection $ \case
-  Just rawConn -> do
-    LibPQ.finish rawConn
-    pure Nothing
-  Nothing ->
-    pure Nothing

lib/Database/PostgreSQL/Opium/Error.hs

@@ -17,9 +17,8 @@ data Error
   | ErrorInvalidOid Text Oid
   | ErrorUnexpectedNull ErrorPosition
   | ErrorInvalidField ErrorPosition Oid ByteString String
-  | ErrorNotExactlyOneRow Int
-  | ErrorMoreThanOneRow Int
-  | ErrorConnectionClosed
+  | ErrorNotExactlyOneRow
+  | ErrorMoreThanOneRow
   deriving (Eq, Show)
 
 instance Exception Error where

lib/Database/PostgreSQL/Opium/FromField.hs

@@ -61,7 +61,7 @@ instance FromField ByteString where
 -- | See https://www.postgresql.org/docs/current/datatype-character.html.
 -- Accepts @text@, @character@ and @character varying@.
 instance FromField Text where
-  validOid Proxy = eq Oid.name \/ eq Oid.text \/ eq Oid.character \/ eq Oid.characterVarying
+  validOid Proxy = eq Oid.text \/ eq Oid.character \/ eq Oid.characterVarying
   parseField = Encoding.decodeUtf8 <$> AP.takeByteString
 
 -- Accepts @text@, @character@ and @character varying@.

lib/Database/PostgreSQL/Opium/Oid.hs

@@ -9,9 +9,6 @@ bytea = Oid 17
 
 -- string types
 
-name :: Oid
-name = Oid 19
-
 text :: Oid
 text = Oid 25
 

lib/Database/PostgreSQL/Opium/ToField.hs

@@ -7,10 +7,8 @@ module Database.PostgreSQL.Opium.ToField
 
 import Data.Bits (Bits (..))
 import Data.ByteString (ByteString)
-import Data.Int (Int32)
 import Data.List (singleton)
 import Data.Text (Text)
-import Data.Time (Day, diffDays, fromGregorian)
 import Data.Word (Word32)
 import Database.PostgreSQL.LibPQ (Format (..), Oid)
 import Unsafe.Coerce (unsafeCoerce)
@@ -50,11 +48,3 @@ instance ToField Float where
 
 instance ToField Double where
   toField x = Just (Oid.doublePrecision, encodeBigEndian @Word 8 $ unsafeCoerce x, Binary)
-
-toPostgresJulian :: Day -> Integer
-toPostgresJulian date = diffDays date postgresEpoch
-  where
-    postgresEpoch = fromGregorian 2000 1 1
-
-instance ToField Day where
-  toField x = Just (Oid.date, encodeBigEndian @Int32 4 $ fromIntegral $ toPostgresJulian x, Binary)

opium.cabal

@@ -20,7 +20,7 @@ name:               opium
 -- PVP summary:     +-+------- breaking API changes
 --                  | | +----- non-breaking API additions
 --                  | | | +--- code changes with no API change
-version:            1.1.1.0
+version:            0.1.0.0
 
 -- A short (one-line) description of the package.
 -- synopsis:
@@ -63,7 +63,6 @@ library
         Database.PostgreSQL.Opium,
         Database.PostgreSQL.Opium.FromField,
         Database.PostgreSQL.Opium.FromRow,
-        Database.PostgreSQL.Opium.Connection,
         Database.PostgreSQL.Opium.ToField
 
     -- Modules included in this library but not exported.
@@ -118,16 +117,13 @@ test-suite opium-test
     other-modules:
         SpecHook,
         Database.PostgreSQL.OpiumSpec,
-        Database.PostgreSQL.Opium.FromFieldSpec,
-        Database.PostgreSQL.Opium.FromRowSpec,
-        Database.PostgreSQL.Opium.ToFieldSpec
+        Database.PostgreSQL.Opium.FromFieldSpec
 
     -- Test dependencies.
     build-depends:
         base,
         opium,
         bytestring,
-        containers,
         hspec,
         postgresql-libpq,
         time,

test/Database/PostgreSQL/Opium/FromFieldSpec.hs

@@ -14,6 +14,7 @@ import Data.Time
   , timeOfDayToTime
   )
 import Data.Text (Text)
+import Database.PostgreSQL.LibPQ (Connection)
 import Database.PostgreSQL.Opium (FromRow)
 import GHC.Generics (Generic)
 import Test.Hspec (SpecWith, describe, it, shouldBe, shouldSatisfy)
@@ -112,7 +113,7 @@ newtype ARawField = ARawField
 
 instance FromRow ARawField where
 
-shouldFetch :: (Eq a, FromRow a, Show a) => Opium.Connection -> Text -> [a] -> IO ()
+shouldFetch :: (Eq a, FromRow a, Show a) => Connection -> Text -> [a] -> IO ()
 shouldFetch conn query expectedRows = do
   actualRows <- Opium.fetch_ query conn
   actualRows `shouldBe` Right expectedRows
@@ -120,7 +121,7 @@ shouldFetch conn query expectedRows = do
 (/\) :: (a -> Bool) -> (a -> Bool) -> a -> Bool
 p /\ q = \x -> p x && q x
 
-spec :: SpecWith Opium.Connection
+spec :: SpecWith Connection
 spec = do
   describe "FromField Int" $ do
     it "Decodes smallint" $ \conn -> do

test/Database/PostgreSQL/Opium/FromRowSpec.hs

@@ -1,92 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TypeApplications #-}
-
-module Database.PostgreSQL.Opium.FromRowSpec (spec) where
-
-import Data.ByteString (ByteString)
-import Data.Proxy (Proxy (..))
-import Test.Hspec (SpecWith, aroundWith, describe, it, shouldBe)
-
-import qualified Database.PostgreSQL.LibPQ as LibPQ
-
-import Database.PostgreSQL.Opium.Connection (unsafeWithRawConnection)
-import Database.PostgreSQL.OpiumSpec (ManyFields (..), MaybeTest (..), Person (..), Only (..))
-
-import qualified Database.PostgreSQL.Opium as Opium
-import qualified Database.PostgreSQL.Opium.FromRow as Opium.FromRow
-
-shouldHaveColumns
-  :: Opium.FromRow a
-  => Proxy a
-  -> LibPQ.Connection
-  -> ByteString
-  -> [LibPQ.Column]
-  -> IO ()
-shouldHaveColumns proxy conn query expectedColumns = do
-  Just result <- LibPQ.execParams conn query [] LibPQ.Binary
-  columnTable <- Opium.getColumnTable proxy result
-  let actualColumns = fmap (map fst . Opium.FromRow.toListColumnTable) columnTable
-  actualColumns `shouldBe` Right expectedColumns
-
--- These test the mapping from Result to ColumnTable/FromRow instances.
-  -- They use the raw LibPQ connection for retrieving the Results.
-spec :: SpecWith Opium.Connection
-spec = aroundWith unsafeWithRawConnection $ do
-  describe "getColumnTable" $ do
-    it "Gets the column table for a result" $ \conn -> do
-      shouldHaveColumns @Person Proxy conn
-        "SELECT name, age FROM person"
-        [0, 1]
-
-    it "Gets the numbers right for funky configurations" $ \conn -> do
-      shouldHaveColumns @Person Proxy conn
-        "SELECT age, name FROM person"
-        [1, 0]
-
-      shouldHaveColumns @Person Proxy conn
-        "SELECT 0 AS a, 1 AS b, 2 AS c, age, 4 AS d, name FROM person"
-        [5, 3]
-
-    it "Fails for missing columns" $ \conn -> do
-      Just result <- LibPQ.execParams conn "SELECT 0 AS a FROM person" [] LibPQ.Binary
-      columnTable <- Opium.getColumnTable @Person Proxy result
-      columnTable `shouldBe` Left (Opium.ErrorMissingColumn "name")
-
-  describe "fromRow" $ do
-    it "Decodes rows in a Result" $ \conn -> do
-      Just result <- LibPQ.execParams conn "SELECT * FROM person" [] LibPQ.Binary
-      Right columnTable <- Opium.getColumnTable @Person Proxy result
-
-      row0 <- Opium.fromRow @Person result columnTable 0
-      row0 `shouldBe` Right (Person "paul" 25)
-
-      row1 <- Opium.fromRow @Person result columnTable 1
-      row1 `shouldBe` Right (Person "albus" 103)
-
-    it "Decodes NULL into Nothing for Maybes" $ \conn -> do
-      Just result <- LibPQ.execParams conn "SELECT NULL AS a" [] LibPQ.Binary
-      Right columnTable <- Opium.getColumnTable @MaybeTest Proxy result
-
-      row <- Opium.fromRow result columnTable 0
-      row `shouldBe` Right (MaybeTest Nothing)
-
-    it "Decodes values into Just for Maybes" $ \conn -> do
-      Just result <- LibPQ.execParams conn "SELECT 'abc' AS a" [] LibPQ.Binary
-      Right columnTable <- Opium.getColumnTable @MaybeTest Proxy result
-
-      row <- Opium.fromRow result columnTable 0
-      row `shouldBe` Right (MaybeTest $ Just "abc")
-
-    it "Works for many fields" $ \conn -> do
-      Just result <- LibPQ.execParams conn "SELECT 'abc' AS a, 42 AS b, 1.0::double precision AS c, 'test' AS d, true AS e" [] LibPQ.Binary
-      Right columnTable <- Opium.getColumnTable @ManyFields Proxy result
-
-      row <- Opium.fromRow result columnTable 0
-      row `shouldBe` Right (ManyFields "abc" 42 1.0 "test" True)
-
-    it "Decodes multiple records into a tuple" $ \conn -> do
-      Just result <- LibPQ.execParams conn "SELECT 'albus' AS name, 123 AS age, 42 AS only" [] LibPQ.Binary
-      Right columnTable <- Opium.getColumnTable @(Person, Only Int) Proxy result
-
-      row <- Opium.fromRow @(Person, Only Int) result columnTable 0
-      row `shouldBe` Right (Person "albus" 123, Only 42)

test/Database/PostgreSQL/Opium/ToFieldSpec.hs

@@ -1,30 +0,0 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE OverloadedStrings #-}
-
-module Database.PostgreSQL.Opium.ToFieldSpec (spec) where
-
-import Data.Functor.Identity (Identity (..))
-import Data.Text (Text)
-import Data.Time (fromGregorian)
-import GHC.Generics (Generic)
-import Test.Hspec (SpecWith, describe, it, shouldBe)
-
-import qualified Database.PostgreSQL.Opium as Opium
-
-newtype Result = Result
-  { a :: Bool
-  } deriving (Show, Eq, Generic)
-
-instance Opium.FromRow Result
-
-shouldBeTrue :: Opium.ToParamList p => Opium.Connection -> Text -> p -> IO ()
-shouldBeTrue conn query params = do
-  result <- Opium.fetch query params conn
-  result `shouldBe` Right (Identity (Result True))
-
-spec :: SpecWith Opium.Connection
-spec = do
-  describe "ToField Day" $ do
-    it "Encodes Day" $ \conn -> do
-      shouldBeTrue conn "SELECT $1 = date '1997-09-29' AS a" (Identity $ fromGregorian 1997 9 29)
-      shouldBeTrue conn "SELECT $1 = date '2025-07-28' AS a" (Identity $ fromGregorian 2025 7 28)

test/Database/PostgreSQL/OpiumSpec.hs

@@ -4,16 +4,20 @@
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE TypeApplications #-}
 
-module Database.PostgreSQL.OpiumSpec (ManyFields (..), MaybeTest (..), Person (..), Only (..), spec) where
+module Database.PostgreSQL.OpiumSpec (spec) where
 
+import Data.ByteString (ByteString)
 import Data.Either (isLeft)
 import Data.Functor.Identity (Identity (..))
+import Data.Proxy (Proxy (..))
 import Data.Text (Text)
+import Database.PostgreSQL.LibPQ (Connection)
 import GHC.Generics (Generic)
 import Test.Hspec (SpecWith, describe, it, shouldBe, shouldSatisfy)
 
 import qualified Database.PostgreSQL.LibPQ as LibPQ
 import qualified Database.PostgreSQL.Opium as Opium
+import qualified Database.PostgreSQL.Opium.FromRow as Opium.FromRow
 
 data Person = Person
   { name :: Text
@@ -51,8 +55,80 @@ newtype Only a = Only
 
 instance Opium.FromField a => Opium.FromRow (Only a) where
 
-spec :: SpecWith Opium.Connection
+shouldHaveColumns
+  :: Opium.FromRow a
+  => Proxy a
+  -> Connection
+  -> ByteString
+  -> [LibPQ.Column]
+  -> IO ()
+shouldHaveColumns proxy conn query expectedColumns = do
+  Just result <- LibPQ.execParams conn query [] LibPQ.Binary
+  columnTable <- Opium.getColumnTable proxy result
+  let actualColumns = fmap (map fst . Opium.FromRow.toListColumnTable) columnTable
+  actualColumns `shouldBe` Right expectedColumns
+
+spec :: SpecWith Connection
 spec = do
+  describe "getColumnTable" $ do
+    it "Gets the column table for a result" $ \conn -> do
+      shouldHaveColumns @Person Proxy conn
+        "SELECT name, age FROM person"
+        [0, 1]
+
+    it "Gets the numbers right for funky configurations" $ \conn -> do
+      shouldHaveColumns @Person Proxy conn
+        "SELECT age, name FROM person"
+        [1, 0]
+
+      shouldHaveColumns @Person Proxy conn
+        "SELECT 0 AS a, 1 AS b, 2 AS c, age, 4 AS d, name FROM person"
+        [5, 3]
+
+    it "Fails for missing columns" $ \conn -> do
+      Just result <- LibPQ.execParams conn "SELECT 0 AS a FROM person" [] LibPQ.Binary
+      columnTable <- Opium.getColumnTable @Person Proxy result
+      columnTable `shouldBe` Left (Opium.ErrorMissingColumn "name")
+
+  describe "fromRow" $ do
+    it "Decodes rows in a Result" $ \conn -> do
+      Just result <- LibPQ.execParams conn "SELECT * FROM person" [] LibPQ.Binary
+      Right columnTable <- Opium.getColumnTable @Person Proxy result
+
+      row0 <- Opium.fromRow @Person result columnTable 0
+      row0 `shouldBe` Right (Person "paul" 25)
+
+      row1 <- Opium.fromRow @Person result columnTable 1
+      row1 `shouldBe` Right (Person "albus" 103)
+
+    it "Decodes NULL into Nothing for Maybes" $ \conn -> do
+      Just result <- LibPQ.execParams conn "SELECT NULL AS a" [] LibPQ.Binary
+      Right columnTable <- Opium.getColumnTable @MaybeTest Proxy result
+
+      row <- Opium.fromRow result columnTable 0
+      row `shouldBe` Right (MaybeTest Nothing)
+
+    it "Decodes values into Just for Maybes" $ \conn -> do
+      Just result <- LibPQ.execParams conn "SELECT 'abc' AS a" [] LibPQ.Binary
+      Right columnTable <- Opium.getColumnTable @MaybeTest Proxy result
+
+      row <- Opium.fromRow result columnTable 0
+      row `shouldBe` Right (MaybeTest $ Just "abc")
+
+    it "Works for many fields" $ \conn -> do
+      Just result <- LibPQ.execParams conn "SELECT 'abc' AS a, 42 AS b, 1.0::double precision AS c, 'test' AS d, true AS e" [] LibPQ.Binary
+      Right columnTable <- Opium.getColumnTable @ManyFields Proxy result
+
+      row <- Opium.fromRow result columnTable 0
+      row `shouldBe` Right (ManyFields "abc" 42 1.0 "test" True)
+
+    it "Decodes multiple records into a tuple" $ \conn -> do
+      Just result <- LibPQ.execParams conn "SELECT 'albus' AS name, 123 AS age, 42 AS only" [] LibPQ.Binary
+      Right columnTable <- Opium.getColumnTable @(Person, Only Int) Proxy result
+
+      row <- Opium.fromRow @(Person, Only Int) result columnTable 0
+      row `shouldBe` Right (Person "albus" 123, Only 42)
+
   describe "fetch" $ do
     it "Passes numbered parameters and retrieves a list of rows" $ \conn -> do
       rows <- Opium.fetch "SELECT ($1 + $2) AS only" (17 :: Int, 25 :: Int) conn
@@ -106,8 +182,3 @@ spec = do
     it "Does not accept two rows when Maybe is the row container type" $ \conn -> do
       row <- Opium.fetch_ @(Only Int) @Maybe "SELECT 17 AS only UNION ALL SELECT 25 AS only" conn
       row `shouldSatisfy` isLeft
-
-  describe "close" $ do
-    it "Does not crash when called twice on the same connection" $ \conn -> do
-      Opium.close conn
-      Opium.close conn

test/SpecHook.hs

@@ -3,15 +3,16 @@
 module SpecHook (hook) where
 
 import Control.Exception (bracket)
+import Database.PostgreSQL.LibPQ (Connection)
 import System.Environment (lookupEnv)
 import Test.Hspec (Spec, SpecWith, around)
 import Text.Printf (printf)
 
 import qualified Data.Text as Text
+import qualified Data.Text.Encoding as Encoding
+import qualified Database.PostgreSQL.LibPQ as LibPQ
 
-import qualified Database.PostgreSQL.Opium as Opium
-
-setupConnection :: IO Opium.Connection
+setupConnection :: IO Connection
 setupConnection = do
   Just dbUser <- lookupEnv "DB_USER"
   Just dbPass <- lookupEnv "DB_PASS"
@@ -19,17 +20,24 @@ setupConnection = do
   Just dbPort <- lookupEnv "DB_PORT"
 
   let dsn = printf "host=localhost user=%s password=%s dbname=%s port=%s" dbUser dbPass dbName dbPort
-  Right conn <- Opium.connect $ Text.pack dsn
+  conn <- LibPQ.connectdb $ Encoding.encodeUtf8 $ Text.pack dsn
+  _ <- LibPQ.setClientEncoding conn "UTF8"
 
-  Right _ <- Opium.execute_ "DROP TABLE IF EXISTS person" conn
-  Right _ <- Opium.execute_ "CREATE TABLE person (name TEXT NOT NULL, age INT NOT NULL, score DOUBLE PRECISION NOT NULL, motto TEXT)" conn
-  Right _ <- Opium.execute_ "INSERT INTO person VALUES ('paul', 25, 30), ('albus', 103, 50.42)" conn
+  _ <- LibPQ.exec conn "CREATE TABLE person (name TEXT NOT NULL, age INT NOT NULL, score DOUBLE PRECISION NOT NULL, motto TEXT)"
+  _ <- LibPQ.exec conn "INSERT INTO person VALUES ('paul', 25, 30), ('albus', 103, 50.42)"
 
   pure conn
 
-teardownConnection :: Opium.Connection -> IO ()
+teardownConnection :: Connection -> IO ()
 teardownConnection conn = do
-  Opium.close conn
+  _ <- LibPQ.exec conn "DROP TABLE person"
+  LibPQ.finish conn
 
-hook :: SpecWith Opium.Connection -> Spec
-hook = around $ bracket setupConnection teardownConnection
+class SpecInput a where
+  hook :: SpecWith a -> Spec
+
+instance SpecInput Connection where
+  hook = around $ bracket setupConnection teardownConnection
+
+instance SpecInput () where
+  hook = id