pqi-conformance 0.1.0.0 → 0.1.0.1

raw patch · 105 files changed

+506/−505 lines, 105 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +6/−0
• pqi-conformance.cabal +1/−6
• src/library/Pqi/Conformance/Harness.hs +5/−5
• src/library/Pqi/Conformance/Observation.hs +35/−35
• src/library/Pqi/Conformance/Operation/BackendPID.hs +1/−1
• src/library/Pqi/Conformance/Operation/Cancel.hs +8/−8
• src/library/Pqi/Conformance/Operation/Cancel/Cleanup.hs +10/−10
• src/library/Pqi/Conformance/Operation/Cancel/Stale.hs +16/−16
• src/library/Pqi/Conformance/Operation/ClientEncoding.hs +5/−5
• src/library/Pqi/Conformance/Operation/CmdStatus.hs +2/−2
• src/library/Pqi/Conformance/Operation/CmdTuples.hs +2/−2
• src/library/Pqi/Conformance/Operation/ConnectPoll.hs +4/−4
• src/library/Pqi/Conformance/Operation/ConnectStart.hs +3/−3
• src/library/Pqi/Conformance/Operation/Connectdb.hs +18/−18
• src/library/Pqi/Conformance/Operation/ConnectionNeedsPassword.hs +1/−1
• src/library/Pqi/Conformance/Operation/ConnectionUsedPassword.hs +1/−1
• src/library/Pqi/Conformance/Operation/ConsumeInput.hs +3/−3
• src/library/Pqi/Conformance/Operation/Db.hs +1/−1
• src/library/Pqi/Conformance/Operation/DescribePortal.hs +4/−4
• src/library/Pqi/Conformance/Operation/DescribePrepared.hs +5/−5
• src/library/Pqi/Conformance/Operation/DisableNoticeReporting.hs +4/−4
• src/library/Pqi/Conformance/Operation/EnableNoticeReporting.hs +3/−3
• src/library/Pqi/Conformance/Operation/EnterPipelineMode.hs +5/−5
• src/library/Pqi/Conformance/Operation/ErrorMessage.hs +16/−16
• src/library/Pqi/Conformance/Operation/EscapeByteaConn.hs +1/−1
• src/library/Pqi/Conformance/Operation/EscapeIdentifier.hs +2/−2
• src/library/Pqi/Conformance/Operation/EscapeStringConn.hs +3/−3
• src/library/Pqi/Conformance/Operation/ExecParams.hs +1/−1
• src/library/Pqi/Conformance/Operation/ExecPrepared.hs +9/−9
• src/library/Pqi/Conformance/Operation/ExitPipelineMode.hs +34/−34
• src/library/Pqi/Conformance/Operation/Fformat.hs +3/−3
• src/library/Pqi/Conformance/Operation/Finish.hs +5/−5
• src/library/Pqi/Conformance/Operation/Flush.hs +4/−4
• src/library/Pqi/Conformance/Operation/Fmod.hs +4/−4
• src/library/Pqi/Conformance/Operation/Fname.hs +4/−4
• src/library/Pqi/Conformance/Operation/Fnumber.hs +2/−2
• src/library/Pqi/Conformance/Operation/Fsize.hs +4/−4
• src/library/Pqi/Conformance/Operation/Ftable.hs +3/−3
• src/library/Pqi/Conformance/Operation/Ftablecol.hs +3/−3
• src/library/Pqi/Conformance/Operation/Ftype.hs +4/−4
• src/library/Pqi/Conformance/Operation/GetCancel.hs +1/−1
• src/library/Pqi/Conformance/Operation/GetNotice.hs +4/−4
• src/library/Pqi/Conformance/Operation/GetResult.hs +1/−1
• src/library/Pqi/Conformance/Operation/Getisnull.hs +4/−4
• src/library/Pqi/Conformance/Operation/Getlength.hs +3/−3
• src/library/Pqi/Conformance/Operation/Getvalue.hs +5/−5
• src/library/Pqi/Conformance/Operation/GetvalueCopy.hs +4/−4
• src/library/Pqi/Conformance/Operation/Host.hs +1/−1
• src/library/Pqi/Conformance/Operation/IsBusy.hs +4/−4
• src/library/Pqi/Conformance/Operation/IsNullConnection.hs +6/−6
• src/library/Pqi/Conformance/Operation/Isnonblocking.hs +3/−3
• src/library/Pqi/Conformance/Operation/LoClose.hs +5/−5
• src/library/Pqi/Conformance/Operation/LoCreat.hs +2/−2
• src/library/Pqi/Conformance/Operation/LoCreate.hs +3/−3
• src/library/Pqi/Conformance/Operation/LoExport.hs +3/−3
• src/library/Pqi/Conformance/Operation/LoImport.hs +2/−2
• src/library/Pqi/Conformance/Operation/LoImportWithOid.hs +3/−3
• src/library/Pqi/Conformance/Operation/LoOpen.hs +5/−5
• src/library/Pqi/Conformance/Operation/LoRead.hs +7/−7
• src/library/Pqi/Conformance/Operation/LoSeek.hs +8/−8
• src/library/Pqi/Conformance/Operation/LoTell.hs +8/−8
• src/library/Pqi/Conformance/Operation/LoTruncate.hs +7/−7
• src/library/Pqi/Conformance/Operation/LoUnlink.hs +3/−3
• src/library/Pqi/Conformance/Operation/LoWrite.hs +5/−5
• src/library/Pqi/Conformance/Operation/NewNullConnection.hs +4/−4
• src/library/Pqi/Conformance/Operation/Nfields.hs +1/−1
• src/library/Pqi/Conformance/Operation/Notifies.hs +22/−22
• src/library/Pqi/Conformance/Operation/Nparams.hs +6/−6
• src/library/Pqi/Conformance/Operation/Ntuples.hs +1/−1
• src/library/Pqi/Conformance/Operation/Options.hs +1/−1
• src/library/Pqi/Conformance/Operation/ParameterStatus.hs +7/−7
• src/library/Pqi/Conformance/Operation/Paramtype.hs +8/−8
• src/library/Pqi/Conformance/Operation/Pass.hs +1/−1
• src/library/Pqi/Conformance/Operation/PipelineStatus.hs +8/−8
• src/library/Pqi/Conformance/Operation/PipelineSync.hs +11/−11
• src/library/Pqi/Conformance/Operation/PipelineSync/Parity.hs +8/−8
• src/library/Pqi/Conformance/Operation/Port.hs +1/−1
• src/library/Pqi/Conformance/Operation/Prepare.hs +3/−3
• src/library/Pqi/Conformance/Operation/ProtocolVersion.hs +1/−1
• src/library/Pqi/Conformance/Operation/PutCopyData.hs +7/−7
• src/library/Pqi/Conformance/Operation/PutCopyEnd.hs +6/−6
• src/library/Pqi/Conformance/Operation/Reset.hs +5/−5
• src/library/Pqi/Conformance/Operation/ResetPoll.hs +4/−4
• src/library/Pqi/Conformance/Operation/ResetStart.hs +3/−3
• src/library/Pqi/Conformance/Operation/ResultErrorMessage.hs +4/−4
• src/library/Pqi/Conformance/Operation/ResultStatus.hs +1/−1
• src/library/Pqi/Conformance/Operation/SendDescribePortal.hs +3/−3
• src/library/Pqi/Conformance/Operation/SendDescribePrepared.hs +2/−2
• src/library/Pqi/Conformance/Operation/SendFlushRequest.hs +5/−5
• src/library/Pqi/Conformance/Operation/SendPrepare.hs +1/−1
• src/library/Pqi/Conformance/Operation/SendQuery.hs +1/−1
• src/library/Pqi/Conformance/Operation/SendQueryParams.hs +1/−1
• src/library/Pqi/Conformance/Operation/SendQueryPrepared.hs +2/−2
• src/library/Pqi/Conformance/Operation/ServerVersion.hs +1/−1
• src/library/Pqi/Conformance/Operation/SetClientEncoding.hs +3/−3
• src/library/Pqi/Conformance/Operation/SetErrorVerbosity.hs +3/−3
• src/library/Pqi/Conformance/Operation/SetSingleRowMode.hs +4/−4
• src/library/Pqi/Conformance/Operation/Setnonblocking.hs +4/−4
• src/library/Pqi/Conformance/Operation/Socket.hs +1/−1
• src/library/Pqi/Conformance/Operation/Status.hs +1/−1
• src/library/Pqi/Conformance/Operation/TransactionStatus.hs +7/−7
• src/library/Pqi/Conformance/Operation/UnescapeBytea.hs +2/−2
• src/library/Pqi/Conformance/Operation/UnsafeFreeResult.hs +2/−2
• src/library/Pqi/Conformance/Operation/User.hs +1/−1
• src/library/Pqi/Conformance/Scenario.hs +7/−7

@@ -1,3 +1,9 @@+# v0.1.0.1++## Fixes++- Removed remaining `OverloadedRecordDot` usages from the source, since that extension (along with `DuplicateRecordFields` and `NoFieldSelectors`) was dropped from the default extensions to support GHC 8.10+ # v0.1.0.0  ## Breaking

@@ -1,6 +1,6 @@ cabal-version: 3.0 name: pqi-conformance-version: 0.1.0.0+version: 0.1.0.1 category: Database, PostgreSQL, Testing synopsis: Differential conformance tests for pqi adapters description:@@ -27,7 +27,6 @@ common base   default-language: Haskell2010   default-extensions:-    ApplicativeDo     BangPatterns     BinaryLiterals     BlockArguments@@ -40,7 +39,6 @@     DeriveTraversable     DerivingStrategies     DerivingVia-    DuplicateRecordFields     EmptyDataDecls     ExistentialQuantification     FlexibleContexts@@ -54,11 +52,9 @@     MultiParamTypeClasses     MultiWayIf     NamedFieldPuns-    NoFieldSelectors     NoImplicitPrelude     NoMonomorphismRestriction     NumericUnderscores-    OverloadedRecordDot     OverloadedStrings     ParallelListComp     PatternGuards@@ -68,7 +64,6 @@     ScopedTypeVariables     StandaloneDeriving     StrictData-    TemplateHaskell     TupleSections     TypeApplications     TypeFamilies

@@ -55,8 +55,8 @@   Expectation differential adapter adminConninfo scenario =   withTestDb adminConninfo \testConninfo -> do-    candidate <- bracket (adapter.connectdb testConninfo) (.finish) scenario-    reference <- bracket (Reference.adapter.connectdb testConninfo) (.finish) scenario+    candidate <- bracket (Pqi.connectdb adapter testConninfo) Pqi.finish scenario+    reference <- bracket (Pqi.connectdb Reference.adapter testConninfo) Pqi.finish scenario     candidate `shouldBe` reference  -- Create a uniquely named database, run the action against it, and drop it on@@ -76,9 +76,9 @@  adminExec :: ByteString -> ByteString -> IO () adminExec conninfo sql = do-  conn <- Reference.adapter.connectdb conninfo-  _ <- conn.exec sql-  conn.finish+  conn <- Pqi.connectdb Reference.adapter conninfo+  _ <- Pqi.exec conn sql+  Pqi.finish conn  -- | Like 'differential', but for scenarios that exercise connection -- establishment itself ('Pqi.connectdb' on a broken conninfo,

@@ -68,45 +68,45 @@ -- | Project a result into a 'ResultObservation'. observeResult :: Lq.Result -> IO ResultObservation observeResult result = do-  status <- result.resultStatus+  status <- Lq.resultStatus result   errorFields <-     traverse-      (\code -> (,) code <$> result.resultErrorField code)+      (\code -> (,) code <$> Lq.resultErrorField result code)       [minBound .. maxBound]-  errorMessage <- result.resultErrorMessage-  ntuples <- result.ntuples-  nfields <- result.nfields-  nparams <- result.nparams-  paramTypes <- traverse result.paramtype [0 .. nparams - 1]+  errorMessage <- Lq.resultErrorMessage result+  ntuples <- Lq.ntuples result+  nfields <- Lq.nfields result+  nparams <- Lq.nparams result+  paramTypes <- traverse (Lq.paramtype result) [0 .. nparams - 1]   fields <- traverse (observeField result) [0 .. nfields - 1]   rows <- traverse (\row -> traverse (observeCell result row) [0 .. nfields - 1]) [0 .. ntuples - 1]-  cmdStatus <- result.cmdStatus-  cmdTuples <- result.cmdTuples+  cmdStatus <- Lq.cmdStatus result+  cmdTuples <- Lq.cmdTuples result   pure ResultObservation {..}  observeField :: Lq.Result -> Int32 -> IO FieldObservation observeField result column = do-  name <- result.fname column-  typeOid <- result.ftype column-  modifier <- result.fmod column-  size <- result.fsize column-  format <- result.fformat column-  tableOid <- result.ftable column-  tableColumn <- result.ftablecol column+  name <- Lq.fname result column+  typeOid <- Lq.ftype result column+  modifier <- Lq.fmod result column+  size <- Lq.fsize result column+  format <- Lq.fformat result column+  tableOid <- Lq.ftable result column+  tableColumn <- Lq.ftablecol result column   pure FieldObservation {..}  observeCell :: Lq.Result -> Int32 -> Int32 -> IO CellObservation observeCell result row column = do-  value <- result.getvalue row column-  isNull <- result.getisnull row column-  length <- result.getlength row column+  value <- Lq.getvalue result row column+  isNull <- Lq.getisnull result row column+  length <- Lq.getlength result row column   pure CellObservation {..}  -- | A snapshot of the comparable portion of a connection's state. The -- candidate and the reference open their connections from the same conninfo -- string, so the conninfo-derived identity accessors agree as well. data ConnectionObservation = ConnectionObservation-  { status :: Lq.ConnStatus,+  { connectionStatus :: Lq.ConnStatus,     transactionStatus :: Lq.TransactionStatus,     serverVersion :: Int,     serverVersionParam :: Maybe ByteString,@@ -119,25 +119,25 @@     options :: Maybe ByteString,     connectionNeedsPassword :: Bool,     connectionUsedPassword :: Bool,-    isNull :: Bool+    connectionIsNull :: Bool   }   deriving stock (Eq, Show)  -- | Project a connection into a 'ConnectionObservation'. observeConnection :: Lq.Connection -> IO ConnectionObservation observeConnection connection = do-  status <- connection.status-  transactionStatus <- connection.transactionStatus-  serverVersion <- connection.serverVersion-  serverVersionParam <- connection.parameterStatus "server_version"-  protocolVersion <- connection.protocolVersion-  db <- connection.db-  user <- connection.user-  pass <- connection.pass-  host <- connection.host-  port <- connection.port-  options <- connection.options-  connectionNeedsPassword <- connection.connectionNeedsPassword-  connectionUsedPassword <- connection.connectionUsedPassword-  let isNull = connection.isNullConnection+  connectionStatus <- Lq.status connection+  transactionStatus <- Lq.transactionStatus connection+  serverVersion <- Lq.serverVersion connection+  serverVersionParam <- Lq.parameterStatus connection "server_version"+  protocolVersion <- Lq.protocolVersion connection+  db <- Lq.db connection+  user <- Lq.user connection+  pass <- Lq.pass connection+  host <- Lq.host connection+  port <- Lq.port connection+  options <- Lq.options connection+  connectionNeedsPassword <- Lq.connectionNeedsPassword connection+  connectionUsedPassword <- Lq.connectionUsedPassword connection+  let connectionIsNull = Lq.isNullConnection connection   pure ConnectionObservation {..}

@@ -17,4 +17,4 @@   describe "backendPID" do     it "is positive on an open connection" \conninfo ->       differential adapter conninfo \connection ->-        (> 0) <$> connection.backendPID+        (> 0) <$> Pqi.backendPID connection

@@ -22,15 +22,15 @@   describe "cancel" do     it "succeeds on an idle connection" \conninfo ->       differential adapter conninfo \connection -> do-        handle <- connection.getCancel-        for handle (.cancel)+        handle <- Pqi.getCancel connection+        for handle Pqi.cancel      it "fails a running query with 57014" \conninfo ->       differential adapter conninfo \connection -> do-        sent <- connection.sendQuery "select pg_sleep(10)"+        sent <- Pqi.sendQuery connection "select pg_sleep(10)"         threadDelay 100000-        handle <- connection.getCancel-        cancelled <- for handle (.cancel)+        handle <- Pqi.getCancel connection+        cancelled <- for handle Pqi.cancel         results <- drainResults connection         usable <- execScenario "select 1" connection         pure (sent, cancelled, results, usable)@@ -38,10 +38,10 @@     it "leaves the connection usable after cancelling a short-running query" \conninfo ->       differential adapter conninfo \connection -> do         outcomes <- replicateM 3 do-          sent <- connection.sendQuery "select pg_sleep(0.1)"+          sent <- Pqi.sendQuery connection "select pg_sleep(0.1)"           threadDelay 50000-          handle <- connection.getCancel-          cancelled <- for handle (.cancel)+          handle <- Pqi.getCancel connection+          cancelled <- for handle Pqi.cancel           results <- drainResults connection           usable <- execScenario "select 1" connection           pure (sent, cancelled, results, usable)

@@ -38,11 +38,11 @@     --   5. exec runs a follow-up command — it must NOT be cancelled by the     --      stale signal that arrived in step 2.     it "does not corrupt subsequent commands when cancel is called after pipeline results are drained" \conninfo ->-      bracket (adapter.connectdb conninfo) (.finish) \connection -> do+      bracket (Lq.connectdb adapter conninfo) Lq.finish \connection -> do         -- Enter pipeline mode and dispatch a fast query.-        _ <- connection.enterPipelineMode-        _ <- connection.sendQueryParams "select 1" [] Lq.Text-        _ <- connection.pipelineSync+        _ <- Lq.enterPipelineMode connection+        _ <- Lq.sendQueryParams connection "select 1" [] Lq.Text+        _ <- Lq.pipelineSync connection          -- Wait for the server to process the query so both messages         -- (CommandComplete + ReadyForQuery) are already in the socket by the@@ -53,7 +53,7 @@         -- After this loop exits, asyncPending=True in pqi-native because         -- ReadyForQuery has not been read yet.         let drainAll = do-              mr <- connection.getResult+              mr <- Lq.getResult connection               case mr of                 Nothing -> pure ()                 Just _ -> drainAll@@ -61,8 +61,8 @@          -- Send cancel.  Because asyncPending=True in pqi-native, a cancel         -- request is dispatched to the server despite the query being done.-        handle <- connection.getCancel-        for_ handle (.cancel)+        handle <- Lq.getCancel connection+        for_ handle Lq.cancel          -- Give the stale cancel enough time to reach the server and set         -- QueryCancelPending before the next command arrives.@@ -72,13 +72,13 @@         drainAll          -- Exit pipeline mode (sends an implicit Sync in the reference impl).-        _ <- connection.exitPipelineMode+        _ <- Lq.exitPipelineMode connection          -- A follow-up command must succeed; 57014 here means the stale cancel         -- corrupted the connection.-        mResult <- connection.exec "select 1"+        mResult <- Lq.exec connection "select 1"         case mResult of           Nothing -> expectationFailure "exec returned no result after pipeline cleanup"           Just result -> do-            status <- result.resultStatus+            status <- Lq.resultStatus result             status `shouldBe` Lq.TuplesOk

@@ -67,16 +67,16 @@   ByteString ->   IO (Maybe (Lq.ExecStatus, Maybe ByteString)) runScenario adapter conninfo =-  bracket (adapter.connectdb conninfo) (.finish) \connection -> do+  bracket (Lq.connectdb adapter conninfo) Lq.finish \connection -> do     -- Build a pipeline with a fast query followed by a slow one, mirroring the     -- sequence hasql issues.  Two prepared statements keep pendingParses in     -- play, matching the real-world reproduction.-    _ <- connection.enterPipelineMode-    _ <- connection.sendPrepare "s1" "select $1::int" Nothing-    _ <- connection.sendQueryPrepared "s1" [Just ("42", Lq.Text)] Lq.Text-    _ <- connection.sendPrepare "s2" "select pg_sleep($1)" (Just [float8Oid])-    _ <- connection.sendQueryPrepared "s2" [Just ("0.1", Lq.Text)] Lq.Text-    _ <- connection.pipelineSync+    _ <- Lq.enterPipelineMode connection+    _ <- Lq.sendPrepare connection "s1" "select $1::int" Nothing+    _ <- Lq.sendQueryPrepared connection "s1" [Just ("42", Lq.Text)] Lq.Text+    _ <- Lq.sendPrepare connection "s2" "select pg_sleep($1)" (Just [float8Oid])+    _ <- Lq.sendQueryPrepared connection "s2" [Just ("0.1", Lq.Text)] Lq.Text+    _ <- Lq.pipelineSync connection      -- Interrupt the read mid-pipeline, exactly as hasql's timeout does: the     -- slow pg_sleep is still running when the read is abandoned.@@ -85,27 +85,27 @@     -- cleanUpAfterInterruption: drain, cancel, drain.  The cancel is sent while     -- the pipeline is mid-flight; on buggy code its SIGINT can arrive late.     _ <- drainResults connection-    mHandle <- connection.getCancel-    _ <- for mHandle (.cancel)+    mHandle <- Lq.getCancel connection+    _ <- for mHandle Lq.cancel     _ <- drainResults connection      -- leavePipeline: the exact restore sequence hasql performs, including the     -- retry it falls back to.-    statusBefore <- connection.pipelineStatus+    statusBefore <- Lq.pipelineStatus connection     when (statusBefore == Lq.PipelineOn) do-      _ <- connection.pipelineSync+      _ <- Lq.pipelineSync connection       _ <- drainResults connection-      _ <- connection.sendFlushRequest+      _ <- Lq.sendFlushRequest connection       _ <- drainResults connection-      ok <- connection.exitPipelineMode+      ok <- Lq.exitPipelineMode connection       unless ok do         _ <- drainResults connection-        void connection.exitPipelineMode+        void (Lq.exitPipelineMode connection)      -- The victim.  It must not be cancelled by the stale signal.     execScenario "select 99" connection >>= \case       Nothing -> pure (Just (Lq.FatalError, Just "no-result"))       Just observation ->-        case observation.status of+        case status observation of           Lq.TuplesOk -> pure Nothing-          status -> pure (Just (status, fromMaybe Nothing (lookup Lq.DiagSqlstate observation.errorFields)))+          status -> pure (Just (status, fromMaybe Nothing (lookup Lq.DiagSqlstate (errorFields observation))))

@@ -17,11 +17,11 @@   describe "clientEncoding" do     it "round-trips and governs result re-encoding" \conninfo ->       differential adapter conninfo \connection -> do-        initial <- connection.clientEncoding-        setOk <- connection.setClientEncoding "LATIN1"-        switched <- connection.clientEncoding-        reported <- connection.parameterStatus "client_encoding"+        initial <- Pqi.clientEncoding connection+        setOk <- Pqi.setClientEncoding connection "LATIN1"+        switched <- Pqi.clientEncoding connection+        reported <- Pqi.parameterStatus connection "client_encoding"         latinCell <- execScenario "select chr(233) as e" connection-        restoreOk <- connection.setClientEncoding "UTF8"+        restoreOk <- Pqi.setClientEncoding connection "UTF8"         utfCell <- execScenario "select chr(233) as e" connection         pure (initial, setOk, switched, reported, latinCell, restoreOk, utfCell)

@@ -15,8 +15,8 @@   describe "cmdStatus" do     it "reports the command tag for each command" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "create temporary table conformance_cmd_status (id int4, label text)"-        let tagOf sql = connection.exec sql >>= traverse (.cmdStatus)+        _ <- Pqi.exec connection "create temporary table conformance_cmd_status (id int4, label text)"+        let tagOf sql = Pqi.exec connection sql >>= traverse Pqi.cmdStatus         insert <- tagOf "insert into conformance_cmd_status values (1, 'a'), (2, 'b')"         update <- tagOf "update conformance_cmd_status set label = 'c' where id = 1"         delete <- tagOf "delete from conformance_cmd_status where id = 2"

@@ -15,8 +15,8 @@   describe "cmdTuples" do     it "reports the affected-row count for each command" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "create temporary table conformance_cmd_tuples (id int4, label text)"-        let countOf sql = connection.exec sql >>= traverse (.cmdTuples)+        _ <- Pqi.exec connection "create temporary table conformance_cmd_tuples (id int4, label text)"+        let countOf sql = Pqi.exec connection sql >>= traverse Pqi.cmdTuples         insert <- countOf "insert into conformance_cmd_tuples values (1, 'a'), (2, 'b')"         update <- countOf "update conformance_cmd_tuples set label = 'c' where id = 1"         delete <- countOf "delete from conformance_cmd_tuples where id = 2"

@@ -16,8 +16,8 @@   describe "connectPoll" do     it "reaches a terminal polling status and a ready connection" \conninfo ->       differentialConnect adapter conninfo \adapter' conninfo' -> do-        connection <- adapter'.connectStart conninfo'-        terminal <- pollUntilDone connection.connectPoll-        connStatus <- connection.status-        connection.finish+        connection <- Pqi.connectStart adapter' conninfo'+        terminal <- pollUntilDone (Pqi.connectPoll connection)+        connStatus <- Pqi.status connection+        Pqi.finish connection         pure (terminal, connStatus)

@@ -17,8 +17,8 @@   describe "connectStart" do     it "begins an asynchronous connection that polls to readiness" \conninfo ->       differentialConnect adapter conninfo \adapter' conninfo' -> do-        connection <- adapter'.connectStart conninfo'-        polled <- pollUntilDone connection.connectPoll+        connection <- Pqi.connectStart adapter' conninfo'+        polled <- pollUntilDone (Pqi.connectPoll connection)         observation <- observeConnection connection-        connection.finish+        Pqi.finish connection         pure (polled, observation)

@@ -27,33 +27,33 @@      it "accepts a URI-format conninfo" \conninfo ->       differentialConnect adapter conninfo \adapter' conninfo' -> do-        connection <- adapter'.connectdb (kvToUri conninfo')-        s <- connection.status-        connection.finish+        connection <- Pqi.connectdb adapter' (kvToUri conninfo')+        s <- Pqi.status connection+        Pqi.finish connection         pure s      it "rejects an unknown database" \conninfo ->       differentialConnect adapter conninfo \adapter' conninfo' -> do-        connection <- adapter'.connectdb (conninfo' <> " dbname=pqi_no_such_db")-        observation <- connection.status-        nullness <- pure connection.isNullConnection-        connection.finish+        connection <- Pqi.connectdb adapter' (conninfo' <> " dbname=pqi_no_such_db")+        observation <- Pqi.status connection+        nullness <- pure (Pqi.isNullConnection connection)+        Pqi.finish connection         pure (observation, nullness)      it "rejects an unknown user" \conninfo ->       differentialConnect adapter conninfo \adapter' conninfo' -> do-        connection <- adapter'.connectdb (conninfo' <> " user=pqi_no_such_user")-        observation <- connection.status-        connection.finish+        connection <- Pqi.connectdb adapter' (conninfo' <> " user=pqi_no_such_user")+        observation <- Pqi.status connection+        Pqi.finish connection         pure observation      it "defaults the user like the reference when user is omitted" \conninfo ->       differentialConnect adapter conninfo \adapter' conninfo' -> do-        connection <- adapter'.connectdb (dropUser conninfo')-        resolvedUser <- connection.user-        observedStatus <- connection.status-        observedError <- connection.errorMessage-        connection.finish+        connection <- Pqi.connectdb adapter' (dropUser conninfo')+        resolvedUser <- Pqi.user connection+        observedStatus <- Pqi.status connection+        observedError <- Pqi.errorMessage connection+        Pqi.finish connection         pure (resolvedUser, observedStatus, observedError)    describe "SCRAM-SHA-256 authentication" do@@ -66,7 +66,7 @@               }            scramScenario :: Pqi.Connection -> IO (Maybe ResultObservation)-          scramScenario connection = connection.exec "select 1 as scram_works" >>= traverse observeResult+          scramScenario connection = Pqi.exec connection "select 1 as scram_works" >>= traverse observeResult        in TcPg.run scramConfig \(host, port) -> do             let conninfo =                   ByteString.Char8.pack@@ -76,8 +76,8 @@                         <> show port                         <> " user=scram password=secret dbname=scram"                     )-            candidate <- bracket (adapter.connectdb conninfo) (.finish) scramScenario-            reference <- bracket (Reference.adapter.connectdb conninfo) (.finish) scramScenario+            candidate <- bracket (Pqi.connectdb adapter conninfo) Pqi.finish scramScenario+            reference <- bracket (Pqi.connectdb Reference.adapter conninfo) Pqi.finish scramScenario             candidate `shouldBe` reference  -- | Drop the @user=…@ token from a @key=value@ conninfo, leaving the user

@@ -14,4 +14,4 @@ spec adapter =   describe "connectionNeedsPassword" do     it "reports whether a password was needed" \conninfo ->-      differential adapter conninfo (.connectionNeedsPassword)+      differential adapter conninfo Pqi.connectionNeedsPassword

@@ -14,4 +14,4 @@ spec adapter =   describe "connectionUsedPassword" do     it "reports whether a password was used" \conninfo ->-      differential adapter conninfo (.connectionUsedPassword)+      differential adapter conninfo Pqi.connectionUsedPassword

@@ -17,11 +17,11 @@   describe "consumeInput" do     it "drives result collection together with isBusy" \conninfo ->       differential adapter conninfo \connection -> do-        sent <- connection.sendQuery "select 42"+        sent <- Pqi.sendQuery connection "select 42"         let settle (0 :: Int) = pure False             settle n = do-              consumed <- connection.consumeInput-              busy <- connection.isBusy+              consumed <- Pqi.consumeInput connection+              busy <- Pqi.isBusy connection               if busy then threadDelay 1000 >> settle (n - 1) else pure consumed         consumed <- settle 10000         results <- drainResults connection

@@ -13,4 +13,4 @@ spec adapter =   describe "db" do     it "reports the database name from the conninfo" \conninfo ->-      differential adapter conninfo (.db)+      differential adapter conninfo Pqi.db

@@ -16,12 +16,12 @@   describe "describePortal" do     it "describes a declared cursor" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "begin"+        _ <- Pqi.exec connection "begin"         _ <--          connection.exec+          Pqi.exec connection             "declare conformance_cursor cursor for select 1 :: int4 as n, 'x' :: text as t"-        connection.describePortal "conformance_cursor" >>= traverse observeResult+        Pqi.describePortal connection "conformance_cursor" >>= traverse observeResult      it "rejects an unknown portal" \conninfo ->       differential adapter conninfo \connection ->-        connection.describePortal "conformance_no_portal" >>= traverse observeResult+        Pqi.describePortal connection "conformance_no_portal" >>= traverse observeResult

@@ -18,14 +18,14 @@   describe "describePrepared" do     it "reports parameter types" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.prepare "conformance_desc" "select $1 :: int4, $2 :: text" Nothing-        connection.describePrepared "conformance_desc" >>= traverse observeResult+        _ <- Pqi.prepare connection "conformance_desc" "select $1 :: int4, $2 :: text" Nothing+        Pqi.describePrepared connection "conformance_desc" >>= traverse observeResult      it "reports explicit parameter types" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.prepare "conformance_typed" "select $1" (Just [int8Oid])-        connection.describePrepared "conformance_typed" >>= traverse observeResult+        _ <- Pqi.prepare connection "conformance_typed" "select $1" (Just [int8Oid])+        Pqi.describePrepared connection "conformance_typed" >>= traverse observeResult      it "rejects an unknown statement" \conninfo ->       differential adapter conninfo \connection ->-        connection.describePrepared "conformance_missing" >>= traverse observeResult+        Pqi.describePrepared connection "conformance_missing" >>= traverse observeResult

@@ -15,13 +15,13 @@   describe "disableNoticeReporting" do     it "stops retaining notices once disabled" \conninfo ->       differential adapter conninfo \connection -> do-        connection.enableNoticeReporting+        Pqi.enableNoticeReporting connection         whileEnabled <- raiseNoticeAndCollect connection-        connection.disableNoticeReporting+        Pqi.disableNoticeReporting connection         whileDisabled <- raiseNoticeAndCollect connection         pure (whileEnabled, whileDisabled)  raiseNoticeAndCollect :: Pqi.Connection -> IO Bool raiseNoticeAndCollect connection = do-  _ <- connection.exec "do $$ begin raise notice 'conformance notice'; end $$"-  isJust <$> connection.getNotice+  _ <- Pqi.exec connection "do $$ begin raise notice 'conformance notice'; end $$"+  isJust <$> Pqi.getNotice connection

@@ -17,11 +17,11 @@     it "makes a raised notice retrievable" \conninfo ->       differential adapter conninfo \connection -> do         beforeEnable <- raiseNoticeAndCollect connection-        connection.enableNoticeReporting+        Pqi.enableNoticeReporting connection         afterEnable <- raiseNoticeAndCollect connection         pure (beforeEnable, afterEnable)  raiseNoticeAndCollect :: Pqi.Connection -> IO Bool raiseNoticeAndCollect connection = do-  _ <- connection.exec "do $$ begin raise notice 'conformance notice'; end $$"-  isJust <$> connection.getNotice+  _ <- Pqi.exec connection "do $$ begin raise notice 'conformance notice'; end $$"+  isJust <$> Pqi.getNotice connection

@@ -15,9 +15,9 @@   describe "enterPipelineMode" do     it "enters pipeline mode and is idempotent" \conninfo ->       differential adapter conninfo \connection -> do-        before <- connection.pipelineStatus-        entered <- connection.enterPipelineMode-        enteredAgain <- connection.enterPipelineMode-        while <- connection.pipelineStatus-        _ <- connection.exitPipelineMode+        before <- Pqi.pipelineStatus connection+        entered <- Pqi.enterPipelineMode connection+        enteredAgain <- Pqi.enterPipelineMode connection+        while <- Pqi.pipelineStatus connection+        _ <- Pqi.exitPipelineMode connection         pure (before, entered, enteredAgain, while)

@@ -26,37 +26,37 @@   describe "errorMessage" do     it "is empty on a healthy connection" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "select 1"-        connection.errorMessage+        _ <- Pqi.exec connection "select 1"+        Pqi.errorMessage connection      it "is populated after a failed exec and cleared by a subsequent success" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "do $$ begin raise exception 'conformance error'; end $$"-        afterFail <- connection.errorMessage-        _ <- connection.exec "select 1"-        afterSuccess <- connection.errorMessage+        _ <- Pqi.exec connection "do $$ begin raise exception 'conformance error'; end $$"+        afterFail <- Pqi.errorMessage connection+        _ <- Pqi.exec connection "select 1"+        afterSuccess <- Pqi.errorMessage connection         pure (afterFail, afterSuccess)      it "is populated after a failed getResult and cleared by a subsequent success" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.sendQuery "do $$ begin raise exception 'conformance error'; end $$"+        _ <- Pqi.sendQuery connection "do $$ begin raise exception 'conformance error'; end $$"         _ <- drainResults connection-        afterFail <- connection.errorMessage-        _ <- connection.sendQuery "select 1"+        afterFail <- Pqi.errorMessage connection+        _ <- Pqi.sendQuery connection "select 1"         _ <- drainResults connection-        afterSuccess <- connection.errorMessage+        afterSuccess <- Pqi.errorMessage connection         pure (afterFail, afterSuccess)      it "is populated after a connection failure" \conninfo ->       differentialConnect adapter conninfo \adapter' conninfo' -> do-        conn <- adapter'.connectdb (conninfo' <> " user=pqi_no_such_user")-        msg <- conn.errorMessage-        conn.finish+        conn <- Pqi.connectdb adapter' (conninfo' <> " user=pqi_no_such_user")+        msg <- Pqi.errorMessage conn+        Pqi.finish conn         pure msg      it "is the null-connection sentinel on a null connection" \conninfo ->       differentialConnect adapter conninfo \adapter' _ -> do-        conn <- adapter'.newNullConnection-        msg <- conn.errorMessage-        conn.finish+        conn <- Pqi.newNullConnection adapter'+        msg <- Pqi.errorMessage conn+        Pqi.finish conn         pure msg

@@ -16,7 +16,7 @@   describe "escapeByteaConn" do     it "escapes a range of binary inputs" \conninfo ->       differential adapter conninfo \connection ->-        traverse connection.escapeByteaConn byteaCases+        traverse (Pqi.escapeByteaConn connection) byteaCases   where     byteaCases =       [ "",

@@ -16,11 +16,11 @@   describe "escapeIdentifier" do     it "escapes a range of identifiers" \conninfo ->       differential adapter conninfo \connection ->-        traverse connection.escapeIdentifier identifierCases+        traverse (Pqi.escapeIdentifier connection) identifierCases      it "produces identifiers that round-trip through a query" \conninfo ->       differential adapter conninfo \connection -> do-        escaped <- connection.escapeIdentifier "Wéird \"column\" name"+        escaped <- Pqi.escapeIdentifier connection "Wéird \"column\" name"         for escaped \identifier ->           execScenario ("select 1 as " <> identifier) connection   where

@@ -16,15 +16,15 @@   describe "escapeStringConn" do     it "escapes a range of strings" \conninfo ->       differential adapter conninfo \connection ->-        traverse connection.escapeStringConn stringCases+        traverse (Pqi.escapeStringConn connection) stringCases      it "rejects invalid encoding" \conninfo ->       differential adapter conninfo \connection ->-        connection.escapeStringConn "\255\254"+        Pqi.escapeStringConn connection "\255\254"      it "produces literals that round-trip through a query" \conninfo ->       differential adapter conninfo \connection -> do-        escaped <- connection.escapeStringConn "it's \\ tricky\nstuff"+        escaped <- Pqi.escapeStringConn connection "it's \\ tricky\nstuff"         for escaped \literal ->           execScenario ("select '" <> literal <> "' :: text") connection   where

@@ -50,7 +50,7 @@           Lq.Text     it "DML with parameters" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "create temporary table conformance_exec_params (id int4)"+        _ <- Lq.exec connection "create temporary table conformance_exec_params (id int4)"         insert <-           observed             "insert into conformance_exec_params values ($1), ($2)"

@@ -17,29 +17,29 @@   describe "execPrepared" do     it "executes a prepared statement" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.prepare "conformance_stmt" "select $1 :: text as a, $2 :: int4 as b" Nothing-        connection.execPrepared "conformance_stmt" [Just ("hello", Lq.Text), Just ("7", Lq.Text)] Lq.Text+        _ <- Lq.prepare connection "conformance_stmt" "select $1 :: text as a, $2 :: int4 as b" Nothing+        Lq.execPrepared connection "conformance_stmt" [Just ("hello", Lq.Text), Just ("7", Lq.Text)] Lq.Text           >>= traverse observeResult      it "executes the unnamed prepared statement" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.prepare "" "select $1 :: int4 + 1" Nothing-        connection.execPrepared "" [Just ("41", Lq.Text)] Lq.Text+        _ <- Lq.prepare connection "" "select $1 :: int4 + 1" Nothing+        Lq.execPrepared connection "" [Just ("41", Lq.Text)] Lq.Text           >>= traverse observeResult      it "executes a zero-parameter statement" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.prepare "conformance_no_params" "select 42" Nothing-        connection.execPrepared "conformance_no_params" [] Lq.Text+        _ <- Lq.prepare connection "conformance_no_params" "select 42" Nothing+        Lq.execPrepared connection "conformance_no_params" [] Lq.Text           >>= traverse observeResult      it "binds null and binary parameters with a binary result" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.prepare "conformance_binary" "select $1 :: text, $2 :: bytea" Nothing-        connection.execPrepared "conformance_binary" [Nothing, Just ("\NUL\1\255", Lq.Binary)] Lq.Binary+        _ <- Lq.prepare connection "conformance_binary" "select $1 :: text, $2 :: bytea" Nothing+        Lq.execPrepared connection "conformance_binary" [Nothing, Just ("\NUL\1\255", Lq.Binary)] Lq.Binary           >>= traverse observeResult      it "rejects an unknown statement" \conninfo ->       differential adapter conninfo \connection ->-        connection.execPrepared "conformance_missing" [] Lq.Text+        Lq.execPrepared connection "conformance_missing" [] Lq.Text           >>= traverse observeResult

@@ -17,20 +17,20 @@   describe "exitPipelineMode" do     it "returns the connection to its non-pipeline status" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.enterPipelineMode-        exited <- connection.exitPipelineMode-        after <- connection.pipelineStatus+        _ <- Lq.enterPipelineMode connection+        exited <- Lq.exitPipelineMode connection+        after <- Lq.pipelineStatus connection         pure (exited, after)      it "fails with work pending and succeeds once drained" \conninfo ->       differential adapter conninfo \connection -> do-        entered <- connection.enterPipelineMode-        sent <- connection.sendQueryParams "select 1" [] Lq.Text-        prematureExit <- connection.exitPipelineMode-        synced <- connection.pipelineSync+        entered <- Lq.enterPipelineMode connection+        sent <- Lq.sendQueryParams connection "select 1" [] Lq.Text+        prematureExit <- Lq.exitPipelineMode connection+        synced <- Lq.pipelineSync connection         results <- takeCommandResults connection         syncResult <- takeResult connection-        exited <- connection.exitPipelineMode+        exited <- Lq.exitPipelineMode connection         pure (entered, sent, prematureExit, synced, results, syncResult, exited)      -- Reproduces the cleanup sequence that hasql's cleanUpAfterInterruption +@@ -41,13 +41,13 @@     -- sequence that hasql uses.     it "recovers after mid-pipeline cancel (mirrors cleanUpAfterInterruption)" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.enterPipelineMode-        _ <- connection.sendPrepare "s1" "select 1" Nothing-        _ <- connection.sendQueryPrepared "s1" [] Lq.Text-        _ <- connection.sendPrepare "s2" "select pg_sleep($1)" (Just [float8Oid])-        _ <- connection.sendQueryPrepared "s2" [Just ("0.5", Lq.Text)] Lq.Text-        _ <- connection.pipelineSync-        _ <- connection.sendFlushRequest+        _ <- Lq.enterPipelineMode connection+        _ <- Lq.sendPrepare connection "s1" "select 1" Nothing+        _ <- Lq.sendQueryPrepared connection "s1" [] Lq.Text+        _ <- Lq.sendPrepare connection "s2" "select pg_sleep($1)" (Just [float8Oid])+        _ <- Lq.sendQueryPrepared connection "s2" [Just ("0.5", Lq.Text)] Lq.Text+        _ <- Lq.pipelineSync connection+        _ <- Lq.sendFlushRequest connection         -- Consume what toPipelineIO would have read before the timeout:         -- parse1 result + separator, exec1 result + separator, parse2 result + separator.         _ <- takeCommandResults connection@@ -55,17 +55,17 @@         _ <- takeCommandResults connection         -- exec2 (pg_sleep) is still running; cancel it to simulate the         -- timeout-triggered cancel in cleanUpAfterInterruption.-        mHandle <- connection.getCancel-        _ <- for mHandle (.cancel)+        mHandle <- Lq.getCancel connection+        _ <- for mHandle Lq.cancel         -- cleanUpAfterInterruption: drain1, then drain2 (after cancel)         _ <- drainResults connection         _ <- drainResults connection         -- leavePipeline: new Sync, drain, Flush, drain-        _ <- connection.pipelineSync+        _ <- Lq.pipelineSync connection         _ <- drainResults connection-        _ <- connection.sendFlushRequest+        _ <- Lq.sendFlushRequest connection         _ <- drainResults connection-        exited <- connection.exitPipelineMode+        exited <- Lq.exitPipelineMode connection         pure exited      -- Reproduces the failure seen in hasql's "Leaves the connection usable@@ -82,35 +82,35 @@     -- captures.     it "recovers after timeout interrupts mid-pipeline read" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.enterPipelineMode-        _ <- connection.sendPrepare "s1" "select $1::int" Nothing-        _ <- connection.sendQueryPrepared "s1" [Just ("42", Lq.Text)] Lq.Text-        _ <- connection.sendPrepare "s2" "select pg_sleep($1)" (Just [float8Oid])-        _ <- connection.sendQueryPrepared "s2" [Just ("0.1", Lq.Text)] Lq.Text-        _ <- connection.pipelineSync+        _ <- Lq.enterPipelineMode connection+        _ <- Lq.sendPrepare connection "s1" "select $1::int" Nothing+        _ <- Lq.sendQueryPrepared connection "s1" [Just ("42", Lq.Text)] Lq.Text+        _ <- Lq.sendPrepare connection "s2" "select pg_sleep($1)" (Just [float8Oid])+        _ <- Lq.sendQueryPrepared connection "s2" [Just ("0.1", Lq.Text)] Lq.Text+        _ <- Lq.pipelineSync connection         -- Interrupt the read just like hasql's Connection.use + timeout does.         _ <- timeout 50000 (drainResults connection)         -- cleanUpAfterInterruption         _ <- drainResults connection-        mHandle <- connection.getCancel-        _ <- for mHandle (.cancel)+        mHandle <- Lq.getCancel connection+        _ <- for mHandle Lq.cancel         _ <- drainResults connection         -- leavePipeline (including the retry that hasql performs)-        pipelineStatusBefore <- connection.pipelineStatus+        pipelineStatusBefore <- Lq.pipelineStatus connection         exited <-           if pipelineStatusBefore == Lq.PipelineOn             then do-              _ <- connection.pipelineSync+              _ <- Lq.pipelineSync connection               _ <- drainResults connection-              _ <- connection.sendFlushRequest+              _ <- Lq.sendFlushRequest connection               _ <- drainResults connection-              ok <- connection.exitPipelineMode+              ok <- Lq.exitPipelineMode connection               if ok                 then pure True                 else do                   _ <- drainResults connection-                  connection.exitPipelineMode+                  Lq.exitPipelineMode connection             else pure True-        afterStatus <- connection.pipelineStatus+        afterStatus <- Lq.pipelineStatus connection         usable <- execScenario "select 99" connection         pure (exited, afterStatus, usable)

@@ -17,10 +17,10 @@     it "follows the requested result format" \conninfo ->       differential adapter conninfo \connection -> do         let formatsOf fmt =-              connection.execParams "select 1 :: int4, 'x' :: text" [] fmt+              Lq.execParams connection "select 1 :: int4, 'x' :: text" [] fmt                 >>= traverse \r -> do-                  n <- r.nfields-                  traverse r.fformat [0 .. n - 1]+                  n <- Lq.nfields r+                  traverse (Lq.fformat r) [0 .. n - 1]         textFormats <- formatsOf Lq.Text         binaryFormats <- formatsOf Lq.Binary         pure (textFormats, binaryFormats)

@@ -15,13 +15,13 @@   describe "finish" do     it "closes an open connection cleanly" \conninfo ->       differentialConnect adapter conninfo \adapter' conninfo' -> do-        connection <- adapter'.connectdb conninfo'-        before <- connection.status-        connection.finish+        connection <- Pqi.connectdb adapter' conninfo'+        before <- Pqi.status connection+        Pqi.finish connection         pure before      it "closes the null sentinel cleanly" \conninfo ->       differentialConnect adapter conninfo \adapter' _ -> do-        connection <- adapter'.newNullConnection-        connection.finish+        connection <- Pqi.newNullConnection adapter'+        Pqi.finish connection         pure ()

@@ -16,9 +16,9 @@   describe "flush" do     it "flushes queued output to completion in non-blocking mode" \conninfo ->       differential adapter conninfo \connection -> do-        setOk <- connection.setnonblocking True-        sent <- connection.sendQuery "select 1"-        flushed <- flushUntilDone connection.flush+        setOk <- Pqi.setnonblocking connection True+        sent <- Pqi.sendQuery connection "select 1"+        flushed <- flushUntilDone (Pqi.flush connection)         results <- drainResults connection-        restoreOk <- connection.setnonblocking False+        restoreOk <- Pqi.setnonblocking connection False         pure (setOk, sent, flushed, results, restoreOk)

@@ -16,9 +16,9 @@     it "reports type modifiers and degrades out of range" \conninfo ->       differential adapter conninfo \connection -> do         result <--          connection.exec "select 1.5 :: numeric(10,2), 'pad' :: char(5), 'x' :: varchar(3), true, 1 :: int4"+          Pqi.exec connection "select 1.5 :: numeric(10,2), 'pad' :: char(5), 'x' :: varchar(3), true, 1 :: int4"         for result \r -> do-          n <- r.nfields-          modifiers <- traverse r.fmod [0 .. n - 1]-          outOfRange <- r.fmod 9+          n <- Pqi.nfields r+          modifiers <- traverse (Pqi.fmod r) [0 .. n - 1]+          outOfRange <- Pqi.fmod r 9           pure (modifiers, outOfRange)

@@ -15,9 +15,9 @@   describe "fname" do     it "names columns and degrades out of range" \conninfo ->       differential adapter conninfo \connection -> do-        result <- connection.exec "select 1 as foo, 2 as bar"+        result <- Pqi.exec connection "select 1 as foo, 2 as bar"         for result \r -> do-          n <- r.nfields-          names <- traverse r.fname [0 .. n - 1]-          outOfRange <- r.fname 5+          n <- Pqi.nfields r+          names <- traverse (Pqi.fname r) [0 .. n - 1]+          outOfRange <- Pqi.fname r 5           pure (names, outOfRange)

@@ -16,8 +16,8 @@   describe "fnumber" do     it "resolves names like an identifier" \conninfo ->       differential adapter conninfo \connection -> do-        result <- connection.exec "select 1 as foo, 2 as \"Bar\""+        result <- Pqi.exec connection "select 1 as foo, 2 as \"Bar\""         for result \r ->           traverse-            r.fnumber+            (Pqi.fnumber r)             ["foo", "FOO", "Foo", "Bar", "bar", "\"Bar\"", "\"foo\"", "missing"]

@@ -15,9 +15,9 @@   describe "fsize" do     it "reports type sizes and degrades out of range" \conninfo ->       differential adapter conninfo \connection -> do-        result <- connection.exec "select 1 :: int2, 1 :: int4, 1 :: int8, 'x' :: text, true"+        result <- Pqi.exec connection "select 1 :: int2, 1 :: int4, 1 :: int8, 'x' :: text, true"         for result \r -> do-          n <- r.nfields-          sizes <- traverse r.fsize [0 .. n - 1]-          outOfRange <- r.fsize 9+          n <- Pqi.nfields r+          sizes <- traverse (Pqi.fsize r) [0 .. n - 1]+          outOfRange <- Pqi.fsize r 9           pure (sizes, outOfRange)

@@ -18,7 +18,7 @@   describe "ftable" do     it "reports the source-table OID, or none for a computed column" \conninfo ->       differential adapter conninfo \connection -> do-        result <- connection.exec "select relname, relkind, 1 as computed from pg_catalog.pg_class where false"+        result <- Pqi.exec connection "select relname, relkind, 1 as computed from pg_catalog.pg_class where false"         for result \r -> do-          n <- r.nfields-          traverse r.ftable [0 .. n - 1]+          n <- Pqi.nfields r+          traverse (Pqi.ftable r) [0 .. n - 1]

@@ -18,7 +18,7 @@   describe "ftablecol" do     it "reports the source-column number, or zero for a computed column" \conninfo ->       differential adapter conninfo \connection -> do-        result <- connection.exec "select relname, relkind, 1 as computed from pg_catalog.pg_class where false"+        result <- Pqi.exec connection "select relname, relkind, 1 as computed from pg_catalog.pg_class where false"         for result \r -> do-          n <- r.nfields-          traverse r.ftablecol [0 .. n - 1]+          n <- Pqi.nfields r+          traverse (Pqi.ftablecol r) [0 .. n - 1]

@@ -15,9 +15,9 @@   describe "ftype" do     it "reports type OIDs and degrades out of range" \conninfo ->       differential adapter conninfo \connection -> do-        result <- connection.exec "select 1 :: int4, 'x' :: text, true, 1.5 :: float8, 1 :: int2"+        result <- Pqi.exec connection "select 1 :: int4, 'x' :: text, true, 1.5 :: float8, 1 :: int2"         for result \r -> do-          n <- r.nfields-          types <- traverse r.ftype [0 .. n - 1]-          outOfRange <- r.ftype 9+          n <- Pqi.nfields r+          types <- traverse (Pqi.ftype r) [0 .. n - 1]+          outOfRange <- Pqi.ftype r 9           pure (types, outOfRange)

@@ -15,4 +15,4 @@   describe "getCancel" do     it "produces a handle for an open connection" \conninfo ->       differential adapter conninfo \connection ->-        isJust <$> connection.getCancel+        isJust <$> Pqi.getCancel connection

@@ -20,8 +20,8 @@   describe "getNotice" do     it "yields the formatted notice while enabled and then drains" \conninfo ->       differential adapter conninfo \connection -> do-        connection.enableNoticeReporting-        _ <- connection.exec "do $$ begin raise notice 'conformance notice'; end $$"-        firstNotice <- connection.getNotice-        afterDrain <- connection.getNotice+        Pqi.enableNoticeReporting connection+        _ <- Pqi.exec connection "do $$ begin raise notice 'conformance notice'; end $$"+        firstNotice <- Pqi.getNotice connection+        afterDrain <- Pqi.getNotice connection         pure (firstNotice, afterDrain)

@@ -16,7 +16,7 @@   describe "getResult" do     it "yields each result then a Nothing terminator" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.sendQuery "select 1 :: int4"+        _ <- Pqi.sendQuery connection "select 1 :: int4"         first <- takeResult connection         terminator <- takeResult connection         afterTerminator <- takeResult connection

@@ -15,9 +15,9 @@   describe "getisnull" do     it "distinguishes null, empty, and non-empty cells" \conninfo ->       differential adapter conninfo \connection -> do-        result <- connection.exec "select 'x' :: text, '' :: text, null :: int4"+        result <- Pqi.exec connection "select 'x' :: text, '' :: text, null :: int4"         for result \r -> do-          nonEmpty <- r.getisnull 0 0-          empty <- r.getisnull 0 1-          nullCell <- r.getisnull 0 2+          nonEmpty <- Pqi.getisnull r 0 0+          empty <- Pqi.getisnull r 0 1+          nullCell <- Pqi.getisnull r 0 2           pure (nonEmpty, empty, nullCell)

@@ -15,7 +15,7 @@   describe "getlength" do     it "reports byte lengths across cell shapes" \conninfo ->       differential adapter conninfo \connection -> do-        result <- connection.exec "select 'hello' :: text, 'héllo' :: text, '' :: text, null :: int4"+        result <- Pqi.exec connection "select 'hello' :: text, 'héllo' :: text, '' :: text, null :: int4"         for result \r -> do-          n <- r.nfields-          traverse (r.getlength 0) [0 .. n - 1]+          n <- Pqi.nfields r+          traverse (Pqi.getlength r 0) [0 .. n - 1]

@@ -15,10 +15,10 @@   describe "getvalue" do     it "reads cells, nulls, and degrades out of range" \conninfo ->       differential adapter conninfo \connection -> do-        result <- connection.exec "select 'hello' :: text, null :: int4"+        result <- Pqi.exec connection "select 'hello' :: text, null :: int4"         for result \r -> do-          present <- r.getvalue 0 0-          nullCell <- r.getvalue 0 1-          badRow <- r.getvalue 1 0-          badColumn <- r.getvalue 0 5+          present <- Pqi.getvalue r 0 0+          nullCell <- Pqi.getvalue r 0 1+          badRow <- Pqi.getvalue r 1 0+          badColumn <- Pqi.getvalue r 0 5           pure (present, nullCell, badRow, badColumn)

@@ -15,9 +15,9 @@   describe "getvalue'" do     it "copies cells that survive freeing the result" \conninfo ->       differential adapter conninfo \connection -> do-        result <- connection.exec "select 'copied' :: text, null :: int4"+        result <- Pqi.exec connection "select 'copied' :: text, null :: int4"         for result \r -> do-          first <- r.getvalue' 0 0-          second <- r.getvalue' 0 1-          r.unsafeFreeResult+          first <- Pqi.getvalue' r 0 0+          second <- Pqi.getvalue' r 0 1+          Pqi.unsafeFreeResult r           pure (first, second)

@@ -13,4 +13,4 @@ spec adapter =   describe "host" do     it "reports the host from the conninfo" \conninfo ->-      differential adapter conninfo (.host)+      differential adapter conninfo Pqi.host

@@ -16,11 +16,11 @@   describe "isBusy" do     it "settles to not-busy after the result arrives" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.sendQuery "select 42"-        let settle (0 :: Int) = connection.isBusy+        _ <- Pqi.sendQuery connection "select 42"+        let settle (0 :: Int) = Pqi.isBusy connection             settle n = do-              _ <- connection.consumeInput-              busy <- connection.isBusy+              _ <- Pqi.consumeInput connection+              busy <- Pqi.isBusy connection               if busy then threadDelay 1000 >> settle (n - 1) else pure busy         stillBusy <- settle 10000         _ <- drainResults connection

@@ -15,10 +15,10 @@   describe "isNullConnection" do     it "is True for the null sentinel and False for an open connection" \conninfo ->       differentialConnect adapter conninfo \adapter' conninfo' -> do-        nullConn <- adapter'.newNullConnection-        let nullIsNull = nullConn.isNullConnection-        nullConn.finish-        openConn <- adapter'.connectdb conninfo'-        let openIsNull = openConn.isNullConnection-        openConn.finish+        nullConn <- Pqi.newNullConnection adapter'+        let nullIsNull = Pqi.isNullConnection nullConn+        Pqi.finish nullConn+        openConn <- Pqi.connectdb adapter' conninfo'+        let openIsNull = Pqi.isNullConnection openConn+        Pqi.finish openConn         pure (nullIsNull, openIsNull)

@@ -15,7 +15,7 @@   describe "isnonblocking" do     it "is off initially and reflects a change" \conninfo ->       differential adapter conninfo \connection -> do-        initially <- connection.isnonblocking-        _ <- connection.setnonblocking True-        afterEnable <- connection.isnonblocking+        initially <- Pqi.isnonblocking connection+        _ <- Pqi.setnonblocking connection True+        afterEnable <- Pqi.isnonblocking connection         pure (initially, afterEnable)

@@ -18,11 +18,11 @@     it "closes the descriptor and invalidates further reads" \conninfo ->       differential adapter conninfo \connection ->         inTransaction connection do-          oid <- connection.loCreat+          oid <- Pqi.loCreat connection           outcome <- for oid \o -> do-            fd <- connection.loOpen o ReadMode-            closed <- for fd (connection.loClose)-            readAfterClose <- join <$> for fd \f -> connection.loRead f 10+            fd <- Pqi.loOpen connection o ReadMode+            closed <- for fd (Pqi.loClose connection)+            readAfterClose <- join <$> for fd \f -> Pqi.loRead connection f 10             pure (closed, readAfterClose)-          traverse_ connection.loUnlink oid+          traverse_ (Pqi.loUnlink connection) oid           pure outcome

@@ -20,6 +20,6 @@     it "creates a large object" \conninfo ->       differential adapter conninfo \connection ->         inTransaction connection do-          oid <- connection.loCreat-          traverse_ connection.loUnlink oid+          oid <- Pqi.loCreat connection+          traverse_ (Pqi.loUnlink connection) oid           pure (isJust oid)

@@ -22,9 +22,9 @@         inTransaction connection do           -- Best-effort cleanup of leftovers from an earlier crashed run; its           -- outcome legitimately differs between runs, so it is not observed.-          _ <- connection.loUnlink explicitOid-          created <- connection.loCreate explicitOid-          unlinked <- for created connection.loUnlink+          _ <- Pqi.loUnlink connection explicitOid+          created <- Pqi.loCreate connection explicitOid+          unlinked <- for created (Pqi.loUnlink connection)           pure (created, unlinked)   where     explicitOid = 424242

@@ -26,9 +26,9 @@         hClose importHandle         (exportPath, exportHandle) <- openBinaryTempFile "/tmp" "pqi-conformance-export-out"         hClose exportHandle-        imported <- connection.loImport importPath-        exported <- for imported \o -> connection.loExport o exportPath-        traverse_ connection.loUnlink imported+        imported <- Pqi.loImport connection importPath+        exported <- for imported \o -> Pqi.loExport connection o exportPath+        traverse_ (Pqi.loUnlink connection) imported         roundTripped <- ByteString.readFile exportPath         removeFile importPath         removeFile exportPath

@@ -24,7 +24,7 @@         (path, handle) <- openBinaryTempFile "/tmp" "pqi-conformance-import"         ByteString.hPut handle "pqi conformance payload"         hClose handle-        imported <- connection.loImport path-        traverse_ connection.loUnlink imported+        imported <- Pqi.loImport connection path+        traverse_ (Pqi.loUnlink connection) imported         removeFile path         pure (isJust imported)

@@ -25,9 +25,9 @@         (path, handle) <- openBinaryTempFile "/tmp" "pqi-conformance-import-oid"         ByteString.hPut handle "pqi conformance payload"         hClose handle-        _ <- connection.loUnlink explicitOid-        imported <- connection.loImportWithOid path explicitOid-        unlinked <- for imported connection.loUnlink+        _ <- Pqi.loUnlink connection explicitOid+        imported <- Pqi.loImportWithOid connection path explicitOid+        unlinked <- for imported (Pqi.loUnlink connection)         removeFile path         pure (imported, unlinked)   where

@@ -18,13 +18,13 @@     it "opens an existing object and rejects a missing one" \conninfo ->       differential adapter conninfo \connection ->         inTransaction connection do-          oid <- connection.loCreat+          oid <- Pqi.loCreat connection           opened <- for oid \o -> do-            fd <- connection.loOpen o ReadWriteMode-            traverse_ connection.loClose fd+            fd <- Pqi.loOpen connection o ReadWriteMode+            traverse_ (Pqi.loClose connection) fd             pure (isJust fd)           loUnlink' oid connection-          missing <- connection.loOpen 4242424 ReadMode+          missing <- Pqi.loOpen connection 4242424 ReadMode           pure (opened, isJust missing)   where-    loUnlink' oid connection = traverse_ connection.loUnlink oid+    loUnlink' oid connection = traverse_ (Pqi.loUnlink connection) oid

@@ -18,14 +18,14 @@     it "reads back what was written" \conninfo ->       differential adapter conninfo \connection ->         inTransaction connection do-          oid <- connection.loCreat+          oid <- Pqi.loCreat connection           outcome <- for oid \o -> do-            fd <- connection.loOpen o ReadWriteMode+            fd <- Pqi.loOpen connection o ReadWriteMode             readBytes <- for fd \f -> do-              _ <- connection.loWrite f "hello, large object"-              _ <- connection.loSeek f AbsoluteSeek 0-              connection.loRead f 5-            traverse_ connection.loClose fd+              _ <- Pqi.loWrite connection f "hello, large object"+              _ <- Pqi.loSeek connection f AbsoluteSeek 0+              Pqi.loRead connection f 5+            traverse_ (Pqi.loClose connection) fd             pure readBytes-          traverse_ connection.loUnlink oid+          traverse_ (Pqi.loUnlink connection) oid           pure outcome

@@ -18,16 +18,16 @@     it "seeks absolutely, relatively, and from the end" \conninfo ->       differential adapter conninfo \connection ->         inTransaction connection do-          oid <- connection.loCreat+          oid <- Pqi.loCreat connection           outcome <- for oid \o -> do-            fd <- connection.loOpen o ReadWriteMode+            fd <- Pqi.loOpen connection o ReadWriteMode             seeks <- for fd \f -> do-              _ <- connection.loWrite f "hello, large object"-              absolute <- connection.loSeek f AbsoluteSeek 0-              relative <- connection.loSeek f RelativeSeek 2-              fromEnd <- connection.loSeek f SeekFromEnd (-6)+              _ <- Pqi.loWrite connection f "hello, large object"+              absolute <- Pqi.loSeek connection f AbsoluteSeek 0+              relative <- Pqi.loSeek connection f RelativeSeek 2+              fromEnd <- Pqi.loSeek connection f SeekFromEnd (-6)               pure (absolute, relative, fromEnd)-            traverse_ connection.loClose fd+            traverse_ (Pqi.loClose connection) fd             pure seeks-          traverse_ connection.loUnlink oid+          traverse_ (Pqi.loUnlink connection) oid           pure outcome

@@ -18,16 +18,16 @@     it "reports the position after a write and a seek" \conninfo ->       differential adapter conninfo \connection ->         inTransaction connection do-          oid <- connection.loCreat+          oid <- Pqi.loCreat connection           outcome <- for oid \o -> do-            fd <- connection.loOpen o ReadWriteMode+            fd <- Pqi.loOpen connection o ReadWriteMode             positions <- for fd \f -> do-              _ <- connection.loWrite f "hello, large object"-              afterWrite <- connection.loTell f-              _ <- connection.loSeek f AbsoluteSeek 3-              afterSeek <- connection.loTell f+              _ <- Pqi.loWrite connection f "hello, large object"+              afterWrite <- Pqi.loTell connection f+              _ <- Pqi.loSeek connection f AbsoluteSeek 3+              afterSeek <- Pqi.loTell connection f               pure (afterWrite, afterSeek)-            traverse_ connection.loClose fd+            traverse_ (Pqi.loClose connection) fd             pure positions-          traverse_ connection.loUnlink oid+          traverse_ (Pqi.loUnlink connection) oid           pure outcome

@@ -18,15 +18,15 @@     it "truncates to a new size" \conninfo ->       differential adapter conninfo \connection ->         inTransaction connection do-          oid <- connection.loCreat+          oid <- Pqi.loCreat connection           outcome <- for oid \o -> do-            fd <- connection.loOpen o ReadWriteMode+            fd <- Pqi.loOpen connection o ReadWriteMode             result <- for fd \f -> do-              _ <- connection.loWrite f "hello, large object"-              truncated <- connection.loTruncate f 5-              newEnd <- connection.loSeek f SeekFromEnd 0+              _ <- Pqi.loWrite connection f "hello, large object"+              truncated <- Pqi.loTruncate connection f 5+              newEnd <- Pqi.loSeek connection f SeekFromEnd 0               pure (truncated, newEnd)-            traverse_ connection.loClose fd+            traverse_ (Pqi.loClose connection) fd             pure result-          traverse_ connection.loUnlink oid+          traverse_ (Pqi.loUnlink connection) oid           pure outcome

@@ -17,7 +17,7 @@     it "removes an existing object and rejects a missing one" \conninfo ->       differential adapter conninfo \connection ->         inTransaction connection do-          oid <- connection.loCreat-          removed <- for oid connection.loUnlink-          missing <- connection.loUnlink 4242424+          oid <- Pqi.loCreat connection+          removed <- for oid (Pqi.loUnlink connection)+          missing <- Pqi.loUnlink connection 4242424           pure (removed, missing)

@@ -17,11 +17,11 @@     it "reports the number of bytes written" \conninfo ->       differential adapter conninfo \connection ->         inTransaction connection do-          oid <- connection.loCreat+          oid <- Pqi.loCreat connection           outcome <- for oid \o -> do-            fd <- connection.loOpen o ReadWriteMode-            written <- for fd \f -> connection.loWrite f "hello, large object"-            traverse_ connection.loClose fd+            fd <- Pqi.loOpen connection o ReadWriteMode+            written <- for fd \f -> Pqi.loWrite connection f "hello, large object"+            traverse_ (Pqi.loClose connection) fd             pure written-          traverse_ connection.loUnlink oid+          traverse_ (Pqi.loUnlink connection) oid           pure outcome

@@ -15,8 +15,8 @@   describe "newNullConnection" do     it "produces a connection that is null and bad" \conninfo ->       differentialConnect adapter conninfo \adapter' _ -> do-        connection <- adapter'.newNullConnection-        nullness <- pure connection.isNullConnection-        badness <- connection.status-        connection.finish+        connection <- Pqi.newNullConnection adapter'+        nullness <- pure (Pqi.isNullConnection connection)+        badness <- Pqi.status connection+        Pqi.finish connection         pure (nullness, badness)

@@ -15,7 +15,7 @@   describe "nfields" do     it "counts columns across result shapes" \conninfo ->       differential adapter conninfo \connection -> do-        let countOf sql = connection.exec sql >>= traverse (.nfields)+        let countOf sql = Pqi.exec connection sql >>= traverse Pqi.nfields         several <- countOf "select 1, 2, 3"         zero <- countOf "select"         command <- countOf "create temporary table conformance_nfields (id int4)"

@@ -5,7 +5,7 @@ -- candidate and the reference are distinct backends — so 'bePid' is omitted -- from the cross-adapter comparison. Each scenario that receives a -- notification instead asserts independently (per adapter) that--- @notification.bePid == backendPID connection@, verifying that the PID field+-- @Pqi.bePid notification == backendPID connection@, verifying that the PID field -- is correctly populated without comparing it across adapters. module Pqi.Conformance.Operation.Notifies   ( spec,@@ -23,36 +23,36 @@   describe "notifies" do     it "is empty with no pending notifications" \conninfo ->       differential adapter conninfo \connection ->-        fmap channelAndPayload <$> connection.notifies+        fmap channelAndPayload <$> Pqi.notifies connection      it "delivers a listen/notify round-trip and then drains" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "listen conformance_channel"-        _ <- connection.exec "notify conformance_channel, 'payload-1'"-        notification <- connection.notifies-        pid <- connection.backendPID-        for_ notification \n -> n.bePid `shouldBe` pid-        drained <- fmap channelAndPayload <$> connection.notifies+        _ <- Pqi.exec connection "listen conformance_channel"+        _ <- Pqi.exec connection "notify conformance_channel, 'payload-1'"+        notification <- Pqi.notifies connection+        pid <- Pqi.backendPID connection+        for_ notification \n -> Pqi.bePid n `shouldBe` pid+        drained <- fmap channelAndPayload <$> Pqi.notifies connection         pure (fmap channelAndPayload notification, drained)      it "queues notifications in order" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "listen conformance_channel"-        _ <- connection.exec "notify conformance_channel, 'first'"-        _ <- connection.exec "notify conformance_channel, 'second'"-        first <- connection.notifies-        second <- connection.notifies-        third <- connection.notifies-        pid <- connection.backendPID-        for_ first \n -> n.bePid `shouldBe` pid-        for_ second \n -> n.bePid `shouldBe` pid+        _ <- Pqi.exec connection "listen conformance_channel"+        _ <- Pqi.exec connection "notify conformance_channel, 'first'"+        _ <- Pqi.exec connection "notify conformance_channel, 'second'"+        first <- Pqi.notifies connection+        second <- Pqi.notifies connection+        third <- Pqi.notifies connection+        pid <- Pqi.backendPID connection+        for_ first \n -> Pqi.bePid n `shouldBe` pid+        for_ second \n -> Pqi.bePid n `shouldBe` pid         pure (fmap channelAndPayload first, fmap channelAndPayload second, fmap channelAndPayload third)      it "stops delivery after unlisten" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "listen conformance_channel"-        _ <- connection.exec "unlisten conformance_channel"-        _ <- connection.exec "notify conformance_channel, 'lost'"-        fmap channelAndPayload <$> connection.notifies+        _ <- Pqi.exec connection "listen conformance_channel"+        _ <- Pqi.exec connection "unlisten conformance_channel"+        _ <- Pqi.exec connection "notify conformance_channel, 'lost'"+        fmap channelAndPayload <$> Pqi.notifies connection   where-    channelAndPayload notification = (notification.relname, notification.extra)+    channelAndPayload notification = (Pqi.relname notification, Pqi.extra notification)

@@ -15,12 +15,12 @@   describe "nparams" do     it "counts the parameters of a prepared statement" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.prepare "conformance_nparams" "select $1 :: int4, $2 :: text" Nothing-        described <- connection.describePrepared "conformance_nparams"-        for described (.nparams)+        _ <- Pqi.prepare connection "conformance_nparams" "select $1 :: int4, $2 :: text" Nothing+        described <- Pqi.describePrepared connection "conformance_nparams"+        for described Pqi.nparams      it "is zero for a parameterless statement" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.prepare "conformance_nparams_zero" "select 42" Nothing-        described <- connection.describePrepared "conformance_nparams_zero"-        for described (.nparams)+        _ <- Pqi.prepare connection "conformance_nparams_zero" "select 42" Nothing+        described <- Pqi.describePrepared connection "conformance_nparams_zero"+        for described Pqi.nparams

@@ -15,7 +15,7 @@   describe "ntuples" do     it "counts rows across result shapes" \conninfo ->       differential adapter conninfo \connection -> do-        let countOf sql = connection.exec sql >>= traverse (.ntuples)+        let countOf sql = Pqi.exec connection sql >>= traverse Pqi.ntuples         many <- countOf "select i from generate_series (1, 3) as i"         none <- countOf "select 1 where false"         command <- countOf "create temporary table conformance_ntuples (id int4)"

@@ -14,4 +14,4 @@ spec adapter =   describe "options" do     it "reports the command-line options from the conninfo" \conninfo ->-      differential adapter conninfo (.options)+      differential adapter conninfo Pqi.options

@@ -15,11 +15,11 @@   describe "parameterStatus" do     it "reports parameter statuses, including GUC_REPORT updates" \conninfo ->       differential adapter conninfo \connection -> do-        before <- connection.parameterStatus "application_name"-        _ <- connection.exec "set application_name to 'pqi-conformance'"-        after <- connection.parameterStatus "application_name"-        clientEncoding <- connection.parameterStatus "client_encoding"-        standardConformingStrings <- connection.parameterStatus "standard_conforming_strings"-        integerDatetimes <- connection.parameterStatus "integer_datetimes"-        missing <- connection.parameterStatus "no_such_parameter"+        before <- Pqi.parameterStatus connection "application_name"+        _ <- Pqi.exec connection "set application_name to 'pqi-conformance'"+        after <- Pqi.parameterStatus connection "application_name"+        clientEncoding <- Pqi.parameterStatus connection "client_encoding"+        standardConformingStrings <- Pqi.parameterStatus connection "standard_conforming_strings"+        integerDatetimes <- Pqi.parameterStatus connection "integer_datetimes"+        missing <- Pqi.parameterStatus connection "no_such_parameter"         pure (before, after, clientEncoding, standardConformingStrings, integerDatetimes, missing)

@@ -16,16 +16,16 @@   describe "paramtype" do     it "reports inferred parameter types" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.prepare "conformance_paramtype" "select $1 :: int4, $2 :: text" Nothing-        described <- connection.describePrepared "conformance_paramtype"+        _ <- Pqi.prepare connection "conformance_paramtype" "select $1 :: int4, $2 :: text" Nothing+        described <- Pqi.describePrepared connection "conformance_paramtype"         for described \r -> do-          n <- r.nparams-          traverse r.paramtype [0 .. n - 1]+          n <- Pqi.nparams r+          traverse (Pqi.paramtype r) [0 .. n - 1]      it "reports explicitly requested parameter types" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.prepare "conformance_paramtype_typed" "select $1" (Just [int8Oid])-        described <- connection.describePrepared "conformance_paramtype_typed"+        _ <- Pqi.prepare connection "conformance_paramtype_typed" "select $1" (Just [int8Oid])+        described <- Pqi.describePrepared connection "conformance_paramtype_typed"         for described \r -> do-          n <- r.nparams-          traverse r.paramtype [0 .. n - 1]+          n <- Pqi.nparams r+          traverse (Pqi.paramtype r) [0 .. n - 1]

@@ -14,4 +14,4 @@ spec adapter =   describe "pass" do     it "reports the password from the conninfo" \conninfo ->-      differential adapter conninfo (.pass)+      differential adapter conninfo Pqi.pass

@@ -18,16 +18,16 @@   describe "pipelineStatus" do     it "reports off, on, aborted, and recovery" \conninfo ->       differential adapter conninfo \connection -> do-        off <- connection.pipelineStatus-        _ <- connection.enterPipelineMode-        on <- connection.pipelineStatus-        _ <- traverse (\sql -> connection.sendQueryParams sql [] Lq.Text) ["select 1", "select 1 / 0", "select 3"]-        _ <- connection.pipelineSync+        off <- Lq.pipelineStatus connection+        _ <- Lq.enterPipelineMode connection+        on <- Lq.pipelineStatus connection+        _ <- traverse (\sql -> Lq.sendQueryParams connection sql [] Lq.Text) ["select 1", "select 1 / 0", "select 3"]+        _ <- Lq.pipelineSync connection         _ <- takeCommandResults connection         _ <- takeCommandResults connection-        aborted <- connection.pipelineStatus+        aborted <- Lq.pipelineStatus connection         _ <- takeCommandResults connection         _ <- takeResult connection-        recovered <- connection.pipelineStatus-        _ <- connection.exitPipelineMode+        recovered <- Lq.pipelineStatus connection+        _ <- Lq.exitPipelineMode connection         pure (off, on, aborted, recovered)

@@ -19,40 +19,40 @@     Parity.spec adapter     it "collects pipelined queries per sync" \conninfo ->       differential adapter conninfo \connection -> do-        entered <- connection.enterPipelineMode+        entered <- Lq.enterPipelineMode connection         sent <-           traverse-            (\sql -> connection.sendQueryParams sql [] Lq.Text)+            (\sql -> Lq.sendQueryParams connection sql [] Lq.Text)             ["select 1 :: int4", "select 'two' :: text", "select 3 :: int4, 'three' :: text"]-        synced <- connection.pipelineSync+        synced <- Lq.pipelineSync connection         first <- takeCommandResults connection         second <- takeCommandResults connection         third <- takeCommandResults connection         syncResult <- takeResult connection         idle <- takeResult connection-        exited <- connection.exitPipelineMode+        exited <- Lq.exitPipelineMode connection         pure (entered, sent, synced, first, second, third, syncResult, idle, exited)      it "aborts the rest of the pipeline after an error" \conninfo ->       differential adapter conninfo \connection -> do-        entered <- connection.enterPipelineMode+        entered <- Lq.enterPipelineMode connection         sent <-           traverse-            (\sql -> connection.sendQueryParams sql [] Lq.Text)+            (\sql -> Lq.sendQueryParams connection sql [] Lq.Text)             ["select 1", "select 1 / 0", "select 3"]-        synced <- connection.pipelineSync+        synced <- Lq.pipelineSync connection         first <- takeCommandResults connection         failed <- takeCommandResults connection         aborted <- takeCommandResults connection         syncResult <- takeResult connection-        exited <- connection.exitPipelineMode+        exited <- Lq.exitPipelineMode connection         pure (entered, sent, synced, first, failed, aborted, syncResult, exited)      it "returns a sync result when called without prior commands" \conninfo ->       differential adapter conninfo \connection -> do-        entered <- connection.enterPipelineMode-        synced <- connection.pipelineSync+        entered <- Lq.enterPipelineMode connection+        synced <- Lq.pipelineSync connection         syncResult <- takeResult connection         trailing <- takeResult connection-        exited <- connection.exitPipelineMode+        exited <- Lq.exitPipelineMode connection         pure (entered, synced, syncResult, trailing, exited)

@@ -25,13 +25,13 @@       differential adapter conninfo \connection -> do         let query = "SELECT 1, 2"         sequential <- replicateM 100 (observed query [] Lq.Text connection)-        entered <- connection.enterPipelineMode-        sent <- replicateM 100 (connection.sendQueryParams query [] Lq.Text)-        synced <- connection.pipelineSync+        entered <- Lq.enterPipelineMode connection+        sent <- replicateM 100 (Lq.sendQueryParams connection query [] Lq.Text)+        synced <- Lq.pipelineSync connection         pipeline <- replicateM 100 (takeCommandResults connection)         syncResult <- takeResult connection         trailing <- takeResult connection-        exited <- connection.exitPipelineMode+        exited <- Lq.exitPipelineMode connection         let pipelineResults = map fst pipeline         sequential `shouldBe` pipelineResults         pure (entered, sent, synced, pipeline, syncResult, trailing, exited, sequential)@@ -40,13 +40,13 @@       differential adapter conninfo \connection -> do         let query = "SELECT generate_series(0,1000) as a, generate_series(1000,2000) as b"         sequential <- replicateM 100 (observed query [] Lq.Text connection)-        entered <- connection.enterPipelineMode-        sent <- replicateM 100 (connection.sendQueryParams query [] Lq.Text)-        synced <- connection.pipelineSync+        entered <- Lq.enterPipelineMode connection+        sent <- replicateM 100 (Lq.sendQueryParams connection query [] Lq.Text)+        synced <- Lq.pipelineSync connection         pipeline <- replicateM 100 (takeCommandResults connection)         syncResult <- takeResult connection         trailing <- takeResult connection-        exited <- connection.exitPipelineMode+        exited <- Lq.exitPipelineMode connection         let pipelineResults = map fst pipeline         sequential `shouldBe` pipelineResults         pure (entered, sent, synced, pipeline, syncResult, trailing, exited, sequential)

@@ -13,4 +13,4 @@ spec adapter =   describe "port" do     it "reports the port from the conninfo" \conninfo ->-      differential adapter conninfo (.port)+      differential adapter conninfo Pqi.port

@@ -16,13 +16,13 @@   describe "prepare" do     it "reports its own result" \conninfo ->       differential adapter conninfo \connection ->-        connection.prepare "conformance_prep_result" "select $1 :: int4" Nothing+        Pqi.prepare connection "conformance_prep_result" "select $1 :: int4" Nothing           >>= traverse observeResult      it "rejects a duplicate statement name" \conninfo ->       differential adapter conninfo \connection -> do         first <--          connection.prepare "conformance_dup" "select 1" Nothing >>= traverse observeResult+          Pqi.prepare connection "conformance_dup" "select 1" Nothing >>= traverse observeResult         second <--          connection.prepare "conformance_dup" "select 2" Nothing >>= traverse observeResult+          Pqi.prepare connection "conformance_dup" "select 2" Nothing >>= traverse observeResult         pure (first, second)

@@ -14,4 +14,4 @@ spec adapter =   describe "protocolVersion" do     it "reports the protocol version" \conninfo ->-      differential adapter conninfo (.protocolVersion)+      differential adapter conninfo Pqi.protocolVersion

@@ -16,11 +16,11 @@   describe "putCopyData" do     it "streams rows into a COPY FROM STDIN" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "create temporary table conformance_copy (id int4, label text)"+        _ <- Pqi.exec connection "create temporary table conformance_copy (id int4, label text)"         started <- execScenario "copy conformance_copy from stdin" connection-        firstRow <- connection.putCopyData "1\thello\n"-        secondRow <- connection.putCopyData "2\tworld\n"-        ended <- connection.putCopyEnd Nothing+        firstRow <- Pqi.putCopyData connection "1\thello\n"+        secondRow <- Pqi.putCopyData connection "2\tworld\n"+        ended <- Pqi.putCopyEnd connection Nothing         outcome <- drainResults connection         check <-           execScenario "select count(*), min(label), max(label) from conformance_copy" connection@@ -28,9 +28,9 @@      it "feeds malformed data that the server rejects" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "create temporary table conformance_copy_bad (id int4)"+        _ <- Pqi.exec connection "create temporary table conformance_copy_bad (id int4)"         started <- execScenario "copy conformance_copy_bad from stdin" connection-        row <- connection.putCopyData "not-a-number\n"-        ended <- connection.putCopyEnd Nothing+        row <- Pqi.putCopyData connection "not-a-number\n"+        ended <- Pqi.putCopyEnd connection Nothing         outcome <- drainResults connection         pure (started, row, ended, outcome)

@@ -16,20 +16,20 @@   describe "putCopyEnd" do     it "commits the copied rows when ended without an error" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "create temporary table conformance_copy_end (id int4)"+        _ <- Pqi.exec connection "create temporary table conformance_copy_end (id int4)"         started <- execScenario "copy conformance_copy_end from stdin" connection-        row <- connection.putCopyData "1\n"-        ended <- connection.putCopyEnd Nothing+        row <- Pqi.putCopyData connection "1\n"+        ended <- Pqi.putCopyEnd connection Nothing         outcome <- drainResults connection         check <- execScenario "select count(*) from conformance_copy_end" connection         pure (started, row, ended, outcome, check)      it "aborts the copy when ended with an error" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "create temporary table conformance_copy_abort (id int4)"+        _ <- Pqi.exec connection "create temporary table conformance_copy_abort (id int4)"         started <- execScenario "copy conformance_copy_abort from stdin" connection-        row <- connection.putCopyData "1\n"-        ended <- connection.putCopyEnd (Just "conformance abort")+        row <- Pqi.putCopyData connection "1\n"+        ended <- Pqi.putCopyEnd connection (Just "conformance abort")         outcome <- drainResults connection         check <- execScenario "select count(*) from conformance_copy_abort" connection         pure (started, row, ended, outcome, check)

@@ -16,11 +16,11 @@   describe "reset" do     it "restores a fresh session" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.prepare "conformance_reset" "select 1" Nothing-        _ <- connection.exec "begin"-        inTransaction <- connection.transactionStatus-        connection.reset+        _ <- Pqi.prepare connection "conformance_reset" "select 1" Nothing+        _ <- Pqi.exec connection "begin"+        inTransaction <- Pqi.transactionStatus connection+        Pqi.reset connection         afterReset <- observeConnection connection         -- The prepared statement must be gone in the fresh session.-        describeAfter <- connection.describePrepared "conformance_reset" >>= traverse observeResult+        describeAfter <- Pqi.describePrepared connection "conformance_reset" >>= traverse observeResult         pure (inTransaction, afterReset, describeAfter)

@@ -16,8 +16,8 @@   describe "resetPoll" do     it "reaches a terminal polling status and a ready connection" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "begin"-        started <- connection.resetStart-        terminal <- pollUntilDone connection.resetPoll-        afterStatus <- connection.transactionStatus+        _ <- Pqi.exec connection "begin"+        started <- Pqi.resetStart connection+        terminal <- pollUntilDone (Pqi.resetPoll connection)+        afterStatus <- Pqi.transactionStatus connection         pure (started, terminal, afterStatus)

@@ -17,8 +17,8 @@   describe "resetStart" do     it "begins an asynchronous reset that polls to a fresh session" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "begin"-        started <- connection.resetStart-        polled <- pollUntilDone connection.resetPoll+        _ <- Pqi.exec connection "begin"+        started <- Pqi.resetStart connection+        polled <- pollUntilDone (Pqi.resetPoll connection)         afterReset <- observeConnection connection         pure (started, polled, afterReset)

@@ -23,9 +23,9 @@     it "matches the full formatted libpq error string on failure and is empty on success" \conninfo ->       differential adapter conninfo \connection -> do         failed <--          connection.exec "do $$ begin raise exception 'conformance error'; end $$"-            >>= traverse (.resultErrorMessage)+          Pqi.exec connection "do $$ begin raise exception 'conformance error'; end $$"+            >>= traverse Pqi.resultErrorMessage         succeeded <--          connection.exec "select 1"-            >>= traverse (.resultErrorMessage)+          Pqi.exec connection "select 1"+            >>= traverse Pqi.resultErrorMessage         pure (failed, succeeded)

@@ -15,7 +15,7 @@   describe "resultStatus" do     it "reports the status for each kind of result" \conninfo ->       differential adapter conninfo \connection -> do-        let statusOf sql = connection.exec sql >>= traverse (.resultStatus)+        let statusOf sql = Pqi.exec connection sql >>= traverse Pqi.resultStatus         tuples <- statusOf "select 1"         command <- statusOf "create temporary table conformance_status (id int4)"         empty <- statusOf ""

@@ -16,8 +16,8 @@   describe "sendDescribePortal" do     it "describes a declared cursor asynchronously" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.exec "begin"-        _ <- connection.exec "declare conformance_async_cursor cursor for select 1 :: int4 as n"-        sent <- connection.sendDescribePortal "conformance_async_cursor"+        _ <- Pqi.exec connection "begin"+        _ <- Pqi.exec connection "declare conformance_async_cursor cursor for select 1 :: int4 as n"+        sent <- Pqi.sendDescribePortal connection "conformance_async_cursor"         results <- drainResults connection         pure (sent, results)

@@ -16,8 +16,8 @@   describe "sendDescribePrepared" do     it "describes a prepared statement asynchronously" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.sendPrepare "conformance_send_desc" "select $1 :: int4 * 2" Nothing+        _ <- Pqi.sendPrepare connection "conformance_send_desc" "select $1 :: int4 * 2" Nothing         _ <- drainResults connection-        sent <- connection.sendDescribePrepared "conformance_send_desc"+        sent <- Pqi.sendDescribePrepared connection "conformance_send_desc"         results <- drainResults connection         pure (sent, results)

@@ -17,11 +17,11 @@   describe "sendFlushRequest" do     it "delivers results without a sync" \conninfo ->       differential adapter conninfo \connection -> do-        entered <- connection.enterPipelineMode-        sent <- connection.sendQueryParams "select 42" [] Lq.Text-        flushRequested <- connection.sendFlushRequest+        entered <- Lq.enterPipelineMode connection+        sent <- Lq.sendQueryParams connection "select 42" [] Lq.Text+        flushRequested <- Lq.sendFlushRequest connection         results <- takeCommandResults connection-        synced <- connection.pipelineSync+        synced <- Lq.pipelineSync connection         syncResult <- takeResult connection-        exited <- connection.exitPipelineMode+        exited <- Lq.exitPipelineMode connection         pure (entered, sent, flushRequested, results, synced, syncResult, exited)

@@ -16,6 +16,6 @@   describe "sendPrepare" do     it "prepares a statement asynchronously" \conninfo ->       differential adapter conninfo \connection -> do-        sent <- connection.sendPrepare "conformance_send_prepare" "select $1 :: int4 * 2" Nothing+        sent <- Pqi.sendPrepare connection "conformance_send_prepare" "select $1 :: int4 * 2" Nothing         results <- drainResults connection         pure (sent, results)

@@ -17,7 +17,7 @@   describe "sendQuery" do     let sendAndDrain sql conninfo =           differential adapter conninfo \connection -> do-            sent <- connection.sendQuery sql+            sent <- Pqi.sendQuery connection sql             results <- drainResults connection             pure (sent, results)     it "sends a query and collects its result"

@@ -18,7 +18,7 @@     it "sends a parameterized query and collects its result" \conninfo ->       differential adapter conninfo \connection -> do         sent <--          connection.sendQueryParams+          Lq.sendQueryParams connection             "select $1 :: int4 + $2 :: int4, $3 :: text"             [Just (int4Oid, "40", Lq.Text), Just (int4Oid, "2", Lq.Text), Nothing]             Lq.Text

@@ -17,8 +17,8 @@   describe "sendQueryPrepared" do     it "executes a prepared statement asynchronously" \conninfo ->       differential adapter conninfo \connection -> do-        _ <- connection.sendPrepare "conformance_send_exec" "select $1 :: int4 * 2" Nothing+        _ <- Lq.sendPrepare connection "conformance_send_exec" "select $1 :: int4 * 2" Nothing         _ <- drainResults connection-        sent <- connection.sendQueryPrepared "conformance_send_exec" [Just ("21", Lq.Text)] Lq.Text+        sent <- Lq.sendQueryPrepared connection "conformance_send_exec" [Just ("21", Lq.Text)] Lq.Text         results <- drainResults connection         pure (sent, results)

@@ -14,4 +14,4 @@ spec adapter =   describe "serverVersion" do     it "reports the server version as an integer" \conninfo ->-      differential adapter conninfo (.serverVersion)+      differential adapter conninfo Pqi.serverVersion

@@ -16,8 +16,8 @@   describe "setClientEncoding" do     it "rejects an unknown encoding and leaves the session usable" \conninfo ->       differential adapter conninfo \connection -> do-        rejected <- connection.setClientEncoding "BOGUS_ENCODING"-        unchanged <- connection.clientEncoding-        stillIdle <- connection.transactionStatus+        rejected <- Pqi.setClientEncoding connection "BOGUS_ENCODING"+        unchanged <- Pqi.clientEncoding connection+        stillIdle <- Pqi.transactionStatus connection         stillWorks <- execScenario "select 1" connection         pure (rejected, unchanged, stillIdle, stillWorks)

@@ -16,7 +16,7 @@   describe "setErrorVerbosity" do     it "returns the previous setting" \conninfo ->       differential adapter conninfo \connection -> do-        beforeTerse <- connection.setErrorVerbosity Lq.ErrorsTerse-        beforeVerbose <- connection.setErrorVerbosity Lq.ErrorsVerbose-        beforeDefault <- connection.setErrorVerbosity Lq.ErrorsDefault+        beforeTerse <- Lq.setErrorVerbosity connection Lq.ErrorsTerse+        beforeVerbose <- Lq.setErrorVerbosity connection Lq.ErrorsVerbose+        beforeDefault <- Lq.setErrorVerbosity connection Lq.ErrorsDefault         pure (beforeTerse, beforeVerbose, beforeDefault)

@@ -16,14 +16,14 @@   describe "setSingleRowMode" do     it "splits a multi-row result into single-row results" \conninfo ->       differential adapter conninfo \connection -> do-        sent <- connection.sendQuery "select i from generate_series (1, 3) as i"-        singleRow <- connection.setSingleRowMode+        sent <- Pqi.sendQuery connection "select i from generate_series (1, 3) as i"+        singleRow <- Pqi.setSingleRowMode connection         results <- drainResults connection         pure (sent, singleRow, results)      it "handles an empty result" \conninfo ->       differential adapter conninfo \connection -> do-        sent <- connection.sendQuery "select 1 where false"-        singleRow <- connection.setSingleRowMode+        sent <- Pqi.sendQuery connection "select 1 where false"+        singleRow <- Pqi.setSingleRowMode connection         results <- drainResults connection         pure (sent, singleRow, results)

@@ -15,8 +15,8 @@   describe "setnonblocking" do     it "turns the non-blocking flag on and off" \conninfo ->       differential adapter conninfo \connection -> do-        setOn <- connection.setnonblocking True-        nowOn <- connection.isnonblocking-        setOff <- connection.setnonblocking False-        nowOff <- connection.isnonblocking+        setOn <- Pqi.setnonblocking connection True+        nowOn <- Pqi.isnonblocking connection+        setOff <- Pqi.setnonblocking connection False+        nowOff <- Pqi.isnonblocking connection         pure (setOn, nowOn, setOff, nowOff)

@@ -17,4 +17,4 @@   describe "socket" do     it "is present on an open connection" \conninfo ->       differential adapter conninfo \connection ->-        isJust <$> connection.socket+        isJust <$> Pqi.socket connection

@@ -13,4 +13,4 @@ spec adapter =   describe "status" do     it "reports a ready connection as OK" \conninfo ->-      differential adapter conninfo (.status)+      differential adapter conninfo Pqi.status

@@ -15,11 +15,11 @@   describe "transactionStatus" do     it "tracks status through a transaction" \conninfo ->       differential adapter conninfo \connection -> do-        idle <- connection.transactionStatus-        _ <- connection.exec "begin"-        inTransaction <- connection.transactionStatus-        _ <- connection.exec "select 1 / 0"-        inError <- connection.transactionStatus-        _ <- connection.exec "rollback"-        afterRollback <- connection.transactionStatus+        idle <- Pqi.transactionStatus connection+        _ <- Pqi.exec connection "begin"+        inTransaction <- Pqi.transactionStatus connection+        _ <- Pqi.exec connection "select 1 / 0"+        inError <- Pqi.transactionStatus connection+        _ <- Pqi.exec connection "rollback"+        afterRollback <- Pqi.transactionStatus connection         pure (idle, inTransaction, inError, afterRollback)

@@ -16,8 +16,8 @@   describe "unescapeBytea" do     for_ cases \input ->       it (show input) \_ -> do-        candidate <- adapter.unescapeBytea input-        reference <- Reference.adapter.unescapeBytea input+        candidate <- Pqi.unescapeBytea adapter input+        reference <- Pqi.unescapeBytea Reference.adapter input         candidate `shouldBe` reference   where     cases =

@@ -21,6 +21,6 @@   describe "unsafeFreeResult" do     it "leaves the connection usable" \conninfo ->       differential adapter conninfo \connection -> do-        result <- connection.exec "select 1"-        traverse_ (.unsafeFreeResult) result+        result <- Pqi.exec connection "select 1"+        traverse_ Pqi.unsafeFreeResult result         execScenario "select 2" connection

@@ -13,4 +13,4 @@ spec adapter =   describe "user" do     it "reports the user name from the conninfo" \conninfo ->-      differential adapter conninfo (.user)+      differential adapter conninfo Pqi.user

@@ -42,7 +42,7 @@  -- | Run 'Pqi.exec' and observe its result (if any). execScenario :: ByteString -> Pqi.Connection -> IO (Maybe ResultObservation)-execScenario sql connection = connection.exec sql >>= traverse observeResult+execScenario sql connection = Pqi.exec connection sql >>= traverse observeResult  -- | Run a sequence of statements with 'Pqi.exec', observing every result. execAllScenario :: [ByteString] -> Pqi.Connection -> IO [Maybe ResultObservation]@@ -56,7 +56,7 @@   Pqi.Connection ->   IO (Maybe ResultObservation) observed sql params resultFormat connection =-  connection.execParams sql params resultFormat >>= traverse observeResult+  Pqi.execParams connection sql params resultFormat >>= traverse observeResult  -- | Collect and observe results with 'Pqi.getResult' until it reports -- completion with 'Nothing'.@@ -64,7 +64,7 @@ drainResults connection = go []   where     go acc =-      connection.getResult >>= \case+      Pqi.getResult connection >>= \case         Nothing -> pure (reverse acc)         Just result -> do           observation <- observeResult result@@ -72,7 +72,7 @@  -- | One 'Pqi.getResult' step, observed. takeResult :: Pqi.Connection -> IO (Maybe ResultObservation)-takeResult connection = connection.getResult >>= traverse observeResult+takeResult connection = Pqi.getResult connection >>= traverse observeResult  -- | The results of one pipelined command: its result and the 'Nothing' -- separator that ends it.@@ -91,7 +91,7 @@   where     go 0 acc = pure (reverse acc)     go n acc =-      connection.getCopyData False >>= \case+      Pqi.getCopyData connection False >>= \case         CopyOutRow row -> go (n - 1) (CopyOutRow row : acc)         terminal -> pure (reverse (terminal : acc)) @@ -122,9 +122,9 @@ -- run inside a transaction block. inTransaction :: Pqi.Connection -> IO a -> IO a inTransaction connection action = do-  _ <- connection.exec "begin"+  _ <- Pqi.exec connection "begin"   result <- action-  _ <- connection.exec "commit"+  _ <- Pqi.exec connection "commit"   pure result  boolOid :: Word32