diff --git a/conflicts-test/Main.hs b/conflicts-test/Main.hs
--- a/conflicts-test/Main.hs
+++ b/conflicts-test/Main.hs
@@ -5,7 +5,7 @@
 import qualified Hasql.Session as B
 import qualified Hasql.Transaction as C
 import qualified Hasql.Transaction.Sessions as G
-import qualified Main.Queries as D
+import qualified Main.Statements as D
 import qualified Main.Transactions as E
 import qualified Control.Concurrent.Async as F
 
@@ -57,14 +57,14 @@
 transactionsTest :: Test
 transactionsTest connection1 connection2 =
   do
-    id1 <- session connection1 (B.query 0 D.createAccount)
-    id2 <- session connection1 (B.query 0 D.createAccount)
+    id1 <- session connection1 (B.statement 0 D.createAccount)
+    id2 <- session connection1 (B.statement 0 D.createAccount)
     async1 <- F.async (replicateM_ 1000 (transaction connection1 (E.transfer id1 id2 1)))
     async2 <- F.async (replicateM_ 1000 (transaction connection2 (E.transfer id1 id2 1)))
     F.wait async1
     F.wait async2
-    balance1 <- session connection1 (B.query id1 D.getBalance)
-    balance2 <- session connection1 (B.query id2 D.getBalance)
+    balance1 <- session connection1 (B.statement id1 D.getBalance)
+    balance2 <- session connection1 (B.statement id2 D.getBalance)
     traceShowM balance1
     traceShowM balance2
     return (balance1 == Just 2000 && balance2 == Just (-2000))
@@ -72,14 +72,14 @@
 readAndWriteTransactionsTest :: Test
 readAndWriteTransactionsTest connection1 connection2 =
   do
-    id1 <- session connection1 (B.query 0 D.createAccount)
-    id2 <- session connection1 (B.query 0 D.createAccount)
+    id1 <- session connection1 (B.statement 0 D.createAccount)
+    id2 <- session connection1 (B.statement 0 D.createAccount)
     async1 <- F.async (replicateM_ 1000 (transaction connection1 (E.transfer id1 id2 1)))
-    async2 <- F.async (replicateM_ 1000 (transaction connection2 (C.query id1 D.getBalance)))
+    async2 <- F.async (replicateM_ 1000 (transaction connection2 (C.statement id1 D.getBalance)))
     F.wait async1
     F.wait async2
-    balance1 <- session connection1 (B.query id1 D.getBalance)
-    balance2 <- session connection1 (B.query id2 D.getBalance)
+    balance1 <- session connection1 (B.statement id1 D.getBalance)
+    balance2 <- session connection1 (B.statement id2 D.getBalance)
     traceShowM balance1
     traceShowM balance2
     return (balance1 == Just 1000 && balance2 == Just (-1000))
@@ -87,14 +87,14 @@
 transactionAndQueryTest :: Test
 transactionAndQueryTest connection1 connection2 =
   do
-    id1 <- session connection1 (B.query 0 D.createAccount)
-    id2 <- session connection1 (B.query 0 D.createAccount)
+    id1 <- session connection1 (B.statement 0 D.createAccount)
+    id2 <- session connection1 (B.statement 0 D.createAccount)
     async1 <- F.async (transaction connection1 (E.transferTimes 200 id1 id2 1))
-    async2 <- F.async (session connection2 (replicateM_ 200 (B.query (id1, 1) D.modifyBalance)))
+    async2 <- F.async (session connection2 (replicateM_ 200 (B.statement (id1, 1) D.modifyBalance)))
     F.wait async1
     F.wait async2
-    balance1 <- session connection1 (B.query id1 D.getBalance)
-    balance2 <- session connection1 (B.query id2 D.getBalance)
+    balance1 <- session connection1 (B.statement id1 D.getBalance)
+    balance2 <- session connection1 (B.statement id2 D.getBalance)
     traceShowM balance1
     traceShowM balance2
     return (balance1 == Just 400 && balance2 == Just (-200))
diff --git a/conflicts-test/Main/Queries.hs b/conflicts-test/Main/Queries.hs
deleted file mode 100644
--- a/conflicts-test/Main/Queries.hs
+++ /dev/null
@@ -1,47 +0,0 @@
-module Main.Queries where
-
-import Rebase.Prelude
-import Hasql.Query
-import qualified Hasql.Encoders as E
-import qualified Hasql.Decoders as D
-
-
-createAccountTable :: Query () ()
-createAccountTable =
-  statement sql E.unit D.unit False
-  where
-    sql =
-      "create table account (id serial not null, balance numeric not null, primary key (id))"
-
-dropAccountTable :: Query () ()
-dropAccountTable =
-  statement
-    "drop table account"
-    E.unit
-    D.unit
-    False
-
-createAccount :: Query Scientific Int64
-createAccount =
-  statement
-    "insert into account (balance) values ($1) returning id"
-    (E.value E.numeric)
-    (D.singleRow (D.value D.int8))
-    True
-
-modifyBalance :: Query (Int64, Scientific) Bool
-modifyBalance =
-  statement
-    "update account set balance = balance + $2 where id = $1"
-    (contrazip2 (E.value E.int8) (E.value E.numeric))
-    (fmap (> 0) D.rowsAffected)
-    True
-
-getBalance :: Query Int64 (Maybe Scientific)
-getBalance =
-  statement
-    "select balance from account where id = $1"
-    (E.value E.int8)
-    (D.maybeRow (D.value D.numeric))
-    True
-
diff --git a/conflicts-test/Main/Statements.hs b/conflicts-test/Main/Statements.hs
new file mode 100644
--- /dev/null
+++ b/conflicts-test/Main/Statements.hs
@@ -0,0 +1,47 @@
+module Main.Statements where
+
+import Rebase.Prelude
+import Hasql.Statement
+import qualified Hasql.Encoders as E
+import qualified Hasql.Decoders as D
+
+
+createAccountTable :: Statement () ()
+createAccountTable =
+  Statement sql E.unit D.unit False
+  where
+    sql =
+      "create table account (id serial not null, balance numeric not null, primary key (id))"
+
+dropAccountTable :: Statement () ()
+dropAccountTable =
+  Statement
+    "drop table account"
+    E.unit
+    D.unit
+    False
+
+createAccount :: Statement Scientific Int64
+createAccount =
+  Statement
+    "insert into account (balance) values ($1) returning id"
+    (E.param E.numeric)
+    (D.singleRow (D.column D.int8))
+    True
+
+modifyBalance :: Statement (Int64, Scientific) Bool
+modifyBalance =
+  Statement
+    "update account set balance = balance + $2 where id = $1"
+    (contrazip2 (E.param E.int8) (E.param E.numeric))
+    (fmap (> 0) D.rowsAffected)
+    True
+
+getBalance :: Statement Int64 (Maybe Scientific)
+getBalance =
+  Statement
+    "select balance from account where id = $1"
+    (E.param E.int8)
+    (D.rowMaybe (D.column D.numeric))
+    True
+
diff --git a/conflicts-test/Main/Transactions.hs b/conflicts-test/Main/Transactions.hs
--- a/conflicts-test/Main/Transactions.hs
+++ b/conflicts-test/Main/Transactions.hs
@@ -2,26 +2,26 @@
 
 import Rebase.Prelude
 import Hasql.Transaction
-import qualified Main.Queries as A
+import qualified Main.Statements as A
 
 
 createSchema :: Transaction ()
 createSchema =
   do
-    query () A.createAccountTable
+    statement () A.createAccountTable
 
 dropSchema :: Transaction ()
 dropSchema =
   do
-    query () A.dropAccountTable
+    statement () A.dropAccountTable
 
 transfer :: Int64 -> Int64 -> Scientific -> Transaction Bool
 transfer id1 id2 amount =
   do
-    success <- query (id1, amount) A.modifyBalance
+    success <- statement (id1, amount) A.modifyBalance
     if success
       then
-        query (id2, negate amount) A.modifyBalance
+        statement (id2, negate amount) A.modifyBalance
       else
         return False
 
diff --git a/hasql-transaction.cabal b/hasql-transaction.cabal
--- a/hasql-transaction.cabal
+++ b/hasql-transaction.cabal
@@ -1,7 +1,7 @@
 name:
   hasql-transaction
 version:
-  0.6.0.1
+  0.7
 category:
   Hasql, Database, PostgreSQL
 synopsis:
@@ -45,7 +45,7 @@
     Hasql.Transaction.Private.Prelude
     Hasql.Transaction.Private.Model
     Hasql.Transaction.Private.SQL
-    Hasql.Transaction.Private.Queries
+    Hasql.Transaction.Private.Statements
     Hasql.Transaction.Private.Sessions
     Hasql.Transaction.Private.Transaction
   exposed-modules:
@@ -53,7 +53,7 @@
     Hasql.Transaction.Sessions
   build-depends:
     -- database:
-    hasql >= 0.19 && < 0.20 || >= 1 && < 1.2,
+    hasql >= 1.3 && < 1.4,
     -- data:
     bytestring-tree-builder >= 0.1 && < 0.3,
     bytestring >= 0.10 && < 0.11,
@@ -75,7 +75,7 @@
   main-is:
     Main.hs
   other-modules:
-    Main.Queries
+    Main.Statements
     Main.Transactions
   ghc-options:
     -O2
diff --git a/library/Hasql/Transaction.hs b/library/Hasql/Transaction.hs
--- a/library/Hasql/Transaction.hs
+++ b/library/Hasql/Transaction.hs
@@ -6,7 +6,7 @@
   Transaction,
   condemn,
   sql,
-  query,
+  statement,
 )
 where
 
diff --git a/library/Hasql/Transaction/Private/Queries.hs b/library/Hasql/Transaction/Private/Queries.hs
deleted file mode 100644
--- a/library/Hasql/Transaction/Private/Queries.hs
+++ /dev/null
@@ -1,50 +0,0 @@
-module Hasql.Transaction.Private.Queries
-where
-
-import Hasql.Transaction.Private.Prelude
-import Hasql.Transaction.Private.Model
-import qualified Hasql.Query as A
-import qualified Hasql.Encoders as B
-import qualified Hasql.Decoders as C
-import qualified Hasql.Transaction.Private.SQL as D
-
-
--- * Transactions
--------------------------
-
-beginTransaction :: IsolationLevel -> Mode -> A.Query () ()
-beginTransaction isolation mode =
-  A.statement (D.beginTransaction isolation mode) B.unit C.unit True
-
-commitTransaction :: A.Query () ()
-commitTransaction =
-  A.statement "COMMIT" B.unit C.unit True
-
-abortTransaction :: A.Query () ()
-abortTransaction =
-  A.statement "ABORT" B.unit C.unit True
-
-
--- * Streaming
--------------------------
-
-declareCursor :: ByteString -> ByteString -> B.Params a -> A.Query a ()
-declareCursor name sql encoder =
-  A.statement (D.declareCursor name sql) encoder C.unit False
-
-closeCursor :: A.Query ByteString ()
-closeCursor =
-  A.statement "CLOSE $1" (B.value B.bytea) C.unit True
-
-fetchFromCursor :: (b -> a -> b) -> b -> C.Row a -> A.Query (Int64, ByteString) b
-fetchFromCursor step init rowDec =
-  A.statement sql encoder decoder True
-  where
-    sql =
-      "FETCH FORWARD $1 FROM $2"
-    encoder =
-      contrazip2
-        (B.value B.int8)
-        (B.value B.bytea)
-    decoder =
-      C.foldlRows step init rowDec
diff --git a/library/Hasql/Transaction/Private/Sessions.hs b/library/Hasql/Transaction/Private/Sessions.hs
--- a/library/Hasql/Transaction/Private/Sessions.hs
+++ b/library/Hasql/Transaction/Private/Sessions.hs
@@ -4,7 +4,7 @@
 import Hasql.Transaction.Private.Prelude
 import Hasql.Transaction.Private.Model
 import qualified Hasql.Session as A
-import qualified Hasql.Transaction.Private.Queries as B
+import qualified Hasql.Transaction.Private.Statements as B
 
 
 {-
@@ -18,17 +18,17 @@
   where
     normal =
       do
-        A.query () (B.beginTransaction isolation mode)
+        A.statement () (B.beginTransaction isolation mode)
         (result, commit) <- session
         if commit
-          then A.query () B.commitTransaction
-          else A.query () B.abortTransaction
+          then A.statement () B.commitTransaction
+          else A.statement () B.abortTransaction
         return result
     onError continue error =
       do
-        A.query () B.abortTransaction
+        A.statement () B.abortTransaction
         case error of
-          A.ResultError (A.ServerError "40001" _ _ _) ->
+          A.QueryError _ _ (A.ResultError (A.ServerError "40001" _ _ _)) ->
             continue
           _ ->
             throwError error
diff --git a/library/Hasql/Transaction/Private/Statements.hs b/library/Hasql/Transaction/Private/Statements.hs
new file mode 100644
--- /dev/null
+++ b/library/Hasql/Transaction/Private/Statements.hs
@@ -0,0 +1,50 @@
+module Hasql.Transaction.Private.Statements
+where
+
+import Hasql.Transaction.Private.Prelude
+import Hasql.Transaction.Private.Model
+import qualified Hasql.Statement as A
+import qualified Hasql.Encoders as B
+import qualified Hasql.Decoders as C
+import qualified Hasql.Transaction.Private.SQL as D
+
+
+-- * Transactions
+-------------------------
+
+beginTransaction :: IsolationLevel -> Mode -> A.Statement () ()
+beginTransaction isolation mode =
+  A.Statement (D.beginTransaction isolation mode) B.unit C.unit True
+
+commitTransaction :: A.Statement () ()
+commitTransaction =
+  A.Statement "COMMIT" B.unit C.unit True
+
+abortTransaction :: A.Statement () ()
+abortTransaction =
+  A.Statement "ABORT" B.unit C.unit True
+
+
+-- * Streaming
+-------------------------
+
+declareCursor :: ByteString -> ByteString -> B.Params a -> A.Statement a ()
+declareCursor name sql encoder =
+  A.Statement (D.declareCursor name sql) encoder C.unit False
+
+closeCursor :: A.Statement ByteString ()
+closeCursor =
+  A.Statement "CLOSE $1" (B.param B.bytea) C.unit True
+
+fetchFromCursor :: (b -> a -> b) -> b -> C.Row a -> A.Statement (Int64, ByteString) b
+fetchFromCursor step init rowDec =
+  A.Statement sql encoder decoder True
+  where
+    sql =
+      "FETCH FORWARD $1 FROM $2"
+    encoder =
+      contrazip2
+        (B.param B.int8)
+        (B.param B.bytea)
+    decoder =
+      C.foldlRows step init rowDec
diff --git a/library/Hasql/Transaction/Private/Transaction.hs b/library/Hasql/Transaction/Private/Transaction.hs
--- a/library/Hasql/Transaction/Private/Transaction.hs
+++ b/library/Hasql/Transaction/Private/Transaction.hs
@@ -3,9 +3,9 @@
 
 import Hasql.Transaction.Private.Prelude
 import Hasql.Transaction.Private.Model
-import qualified Hasql.Query as A
+import qualified Hasql.Statement as A
 import qualified Hasql.Session as B
-import qualified Hasql.Transaction.Private.Queries as C
+import qualified Hasql.Transaction.Private.Statements as C
 import qualified Hasql.Transaction.Private.Sessions as D
 
 
@@ -37,10 +37,10 @@
 
 -- |
 -- Parameters and a specification of the parametric query to apply them to.
-{-# INLINE query #-}
-query :: a -> A.Query a b -> Transaction b
-query params query =
-  Transaction . lift $ B.query params query
+{-# INLINE statement #-}
+statement :: a -> A.Statement a b -> Transaction b
+statement params statement =
+  Transaction . lift $ B.statement params statement
 
 -- |
 -- Cause transaction to eventually roll back.