diff --git a/relational-query-HDBC.cabal b/relational-query-HDBC.cabal
--- a/relational-query-HDBC.cabal
+++ b/relational-query-HDBC.cabal
@@ -1,5 +1,5 @@
 name:                relational-query-HDBC
-version:             0.2.0.2
+version:             0.3.0.0
 synopsis:            HDBC instance of relational-query and typed query interface for HDBC
 description:         This package contains the HDBC instance of relational-query and
                      the typed query interface for HDBC.
diff --git a/src/Database/HDBC/Record/Delete.hs b/src/Database/HDBC/Record/Delete.hs
--- a/src/Database/HDBC/Record/Delete.hs
+++ b/src/Database/HDBC/Record/Delete.hs
@@ -12,7 +12,7 @@
 -- This module provides typed 'Delete' running sequence
 -- which intermediate structres are typed.
 module Database.HDBC.Record.Delete (
-  PreparedDelete, prepare, prepareDelete,
+  PreparedDelete, prepare, prepareDelete, withPrepareDelete,
 
   runPreparedDelete, runDelete
   ) where
@@ -23,7 +23,7 @@
 import Database.Record (ToSql)
 
 import Database.HDBC.Record.Statement
-  (prepareNoFetch, PreparedStatement, runPreparedNoFetch, runNoFetch)
+  (prepareNoFetch, withPrepareNoFetch, PreparedStatement, runPreparedNoFetch, runNoFetch)
 
 
 -- | Typed prepared delete type.
@@ -42,6 +42,14 @@
               -> Delete p
               -> IO (PreparedDelete p)
 prepareDelete = prepare
+
+-- | Bracketed prepare operation.
+withPrepareDelete :: IConnection conn
+              => conn
+              -> Delete p
+              -> (PreparedDelete p -> IO a)
+              -> IO a
+withPrepareDelete = withPrepareNoFetch
 
 -- | Bind parameters, execute statement and get execution result.
 runPreparedDelete :: ToSql SqlValue p
diff --git a/src/Database/HDBC/Record/Insert.hs b/src/Database/HDBC/Record/Insert.hs
--- a/src/Database/HDBC/Record/Insert.hs
+++ b/src/Database/HDBC/Record/Insert.hs
@@ -16,7 +16,7 @@
 
   runPreparedInsert, runInsert, mapInsert,
 
-  chunksInsertActions, chunksInsert,
+  chunksInsert,
   ) where
 
 import Database.HDBC (IConnection, SqlValue)
@@ -25,8 +25,8 @@
 import Database.Record (ToSql, fromRecord)
 
 import Database.HDBC.Record.Statement
-  (prepareNoFetch, unsafePrepare, PreparedStatement, untypePrepared, BoundStatement (..),
-   runPreparedNoFetch, runNoFetch, mapNoFetch, executeNoFetch)
+  (prepareNoFetch, withPrepareNoFetch, withUnsafePrepare, PreparedStatement, untypePrepared,
+   BoundStatement (..), runPreparedNoFetch, runNoFetch, mapNoFetch, executeNoFetch)
 
 
 -- | Typed prepared insert type.
@@ -84,25 +84,33 @@
     | otherwise  =  Right c : rec' tl  where
       (c, tl) = splitAt n xs
 
--- | Prepare and insert with chunk insert statement. Result is insert action list.
-{-# DEPRECATED chunksInsertActions "Difficult to release around prepared statement resources." #-}
-chunksInsertActions :: (IConnection conn, ToSql SqlValue a)
-                    => conn
-                    -> Insert a
-                    -> [a]
-                    -> IO [ IO [Integer] ]
-chunksInsertActions conn i0 rs = do
-  ins    <- unsafePrepare conn $ untypeInsert i0
-  iChunk <- unsafePrepare conn $ untypeChunkInsert i0
-  let insert (Right c) = do
-        rv <- executeNoFetch $ chunkBind iChunk c
-        return [rv]
-      insert (Left  c) =
-        mapM (runPreparedInsert ins) c
-  return . map insert $ chunks (chunkSizeOfInsert i0) rs
+withPrepareChunksInsert :: (IConnection conn, ToSql SqlValue a)
+                        => conn
+                        -> Insert a
+                        -> (PreparedInsert a -> PreparedStatement [p] () -> Int -> IO b)
+                        -> IO b
+withPrepareChunksInsert conn i0 body =
+  withPrepareNoFetch conn i0
+  (\ins -> withUnsafePrepare conn (untypeChunkInsert i0)
+           (\iChunk -> body ins iChunk $ chunkSizeOfInsert i0)  )
 
+-- Prepare and insert with chunk insert statement.
+chunksInsertActions :: ToSql SqlValue a
+                 => [a]
+                 -> PreparedInsert a
+                 -> PreparedStatement [a] ()
+                 -> Int
+                 -> IO [[Integer]]
+chunksInsertActions rs ins iChunk size =
+    mapM insert $ chunks size rs
+  where
+    insert (Right c) = do
+      rv <- executeNoFetch $ chunkBind iChunk c
+      return [rv]
+    insert (Left  c) =
+      mapM (runPreparedInsert ins) c
+
 -- | Prepare and insert with chunk insert statement.
 chunksInsert :: (IConnection conn, ToSql SqlValue a) => conn -> Insert a -> [a] -> IO [[Integer]]
-chunksInsert conn ins rs = do
-  as <- chunksInsertActions conn ins rs
-  sequence as
+chunksInsert conn ins rs =
+  withPrepareChunksInsert conn ins $ chunksInsertActions rs
diff --git a/src/Database/HDBC/Record/InsertQuery.hs b/src/Database/HDBC/Record/InsertQuery.hs
--- a/src/Database/HDBC/Record/InsertQuery.hs
+++ b/src/Database/HDBC/Record/InsertQuery.hs
@@ -12,7 +12,7 @@
 -- This module provides typed 'InsertQuery' running sequence
 -- which intermediate structres are typed.
 module Database.HDBC.Record.InsertQuery (
-  PreparedInsertQuery, prepare, prepareInsertQuery,
+  PreparedInsertQuery, prepare, prepareInsertQuery, withPrepareInsertQuery,
 
   runPreparedInsertQuery, runInsertQuery
   ) where
@@ -23,7 +23,7 @@
 import Database.Record (ToSql)
 
 import Database.HDBC.Record.Statement
-  (prepareNoFetch, PreparedStatement, runPreparedNoFetch)
+  (prepareNoFetch, withPrepareNoFetch, PreparedStatement, runPreparedNoFetch, runNoFetch)
 
 -- | Typed prepared insert query type.
 type PreparedInsertQuery p = PreparedStatement p ()
@@ -42,6 +42,14 @@
                    -> IO (PreparedInsertQuery p)
 prepareInsertQuery = prepare
 
+-- | Bracketed prepare operation.
+withPrepareInsertQuery :: IConnection conn
+                       => conn
+                       -> InsertQuery p
+                       -> (PreparedInsertQuery p -> IO a)
+                       -> IO a
+withPrepareInsertQuery = withPrepareNoFetch
+
 -- | Bind parameters, execute statement and get execution result.
 runPreparedInsertQuery :: ToSql SqlValue p
                        => PreparedInsertQuery p
@@ -56,4 +64,4 @@
                -> InsertQuery p
                -> p
                -> IO Integer
-runInsertQuery conn q p = prepareInsertQuery conn q >>= (`runPreparedInsertQuery` p)
+runInsertQuery =  runNoFetch
diff --git a/src/Database/HDBC/Record/KeyUpdate.hs b/src/Database/HDBC/Record/KeyUpdate.hs
--- a/src/Database/HDBC/Record/KeyUpdate.hs
+++ b/src/Database/HDBC/Record/KeyUpdate.hs
@@ -14,13 +14,14 @@
 module Database.HDBC.Record.KeyUpdate (
   PreparedKeyUpdate,
 
-  prepare, prepareKeyUpdate,
+  prepare, prepareKeyUpdate, withPrepareKeyUpdate,
 
   bindKeyUpdate,
 
   runPreparedKeyUpdate, runKeyUpdate
   ) where
 
+import Control.Exception (bracket)
 import Database.HDBC (IConnection, SqlValue, Statement)
 import qualified Database.HDBC as HDBC
 
@@ -59,6 +60,19 @@
                  -> IO (PreparedKeyUpdate p a)
 prepareKeyUpdate =  prepare
 
+-- | Bracketed prepare operation.
+withPrepareKeyUpdate :: IConnection conn
+                     => conn
+                     -> KeyUpdate p a
+                     -> (PreparedKeyUpdate p a -> IO b)
+                     -> IO b
+withPrepareKeyUpdate conn ku body =
+    bracket (HDBC.prepare conn sql) HDBC.finish
+    $ body . PreparedKeyUpdate key
+  where
+    sql = untypeKeyUpdate ku
+    key = Query.updateKey ku
+
 -- | Typed operation to bind parameters for 'PreparedKeyUpdate' type.
 bindKeyUpdate :: ToSql SqlValue a
               => PreparedKeyUpdate p a
@@ -82,4 +96,4 @@
              -> KeyUpdate p a
              -> a
              -> IO Integer
-runKeyUpdate conn q a = prepareKeyUpdate conn q >>= (`runPreparedKeyUpdate` a)
+runKeyUpdate conn q a = withPrepareKeyUpdate conn q (`runPreparedKeyUpdate` a)
diff --git a/src/Database/HDBC/Record/Query.hs b/src/Database/HDBC/Record/Query.hs
--- a/src/Database/HDBC/Record/Query.hs
+++ b/src/Database/HDBC/Record/Query.hs
@@ -12,7 +12,7 @@
 -- This module provides typed 'Query' running sequence
 -- which intermediate structres are typed.
 module Database.HDBC.Record.Query (
-  PreparedQuery, prepare, prepareQuery,
+  PreparedQuery, prepare, prepareQuery, withPrepareQuery,
 
   fetch, fetchAll, fetchAll',
   listToUnique, fetchUnique, fetchUnique',
@@ -31,7 +31,7 @@
   (ToSql, RecordFromSql, FromSql(recordFromSql), runToRecord)
 
 import Database.HDBC.Record.Statement
-  (unsafePrepare, PreparedStatement,
+  (unsafePrepare, withUnsafePrepare, PreparedStatement,
    bind, BoundStatement,
    execute, ExecutedStatement, executed)
 
@@ -53,6 +53,14 @@
              -> IO (PreparedQuery p a) -- ^ Result typed prepared query with parameter type 'p' and result type 'a'
 prepareQuery = prepare
 
+-- | Bracketed prepare operation.
+withPrepareQuery :: IConnection conn
+                 => conn                        -- ^ Database connection
+                 -> Query p a                   -- ^ Typed query
+                 -> (PreparedQuery p a -> IO b) -- ^ Body action to use prepared statement
+                 -> IO b                        -- ^ Result action
+withPrepareQuery conn = withUnsafePrepare conn . untypeQuery
+
 -- | Polymorphic fetch operation.
 fetchRecordsExplicit :: Functor f
                      => (Statement -> IO (f [SqlValue]) )
@@ -138,4 +146,4 @@
           -> Query p a -- ^ Query to get record type 'a' requires parameter 'p'
           -> p         -- ^ Parameter type
           -> IO [a]    -- ^ Action to get records
-runQuery' conn q p = prepare conn q >>= (`runPreparedQuery'` p)
+runQuery' conn q p = withPrepareQuery conn q (`runPreparedQuery'` p)
diff --git a/src/Database/HDBC/Record/Statement.hs b/src/Database/HDBC/Record/Statement.hs
--- a/src/Database/HDBC/Record/Statement.hs
+++ b/src/Database/HDBC/Record/Statement.hs
@@ -12,8 +12,10 @@
 -- This module provides typed statement running sequence
 -- which intermediate structres are typed.
 module Database.HDBC.Record.Statement (
-  PreparedStatement, untypePrepared, unsafePrepare,
+  PreparedStatement, untypePrepared, unsafePrepare, finish,
 
+  withUnsafePrepare, withPrepareNoFetch,
+
   BoundStatement (..), bind', bind, bindTo,
 
   ExecutedStatement, executed, result, execute,
@@ -21,6 +23,7 @@
   prepareNoFetch, executeNoFetch, runPreparedNoFetch, runNoFetch, mapNoFetch
   ) where
 
+import Control.Exception (bracket)
 import Database.Relational.Query (UntypeableNoFetch (untypeNoFetch))
 import Database.HDBC (IConnection, Statement, SqlValue)
 import qualified Database.HDBC as HDBC
@@ -72,6 +75,30 @@
                -> IO (PreparedStatement p ())
 prepareNoFetch conn = unsafePrepare conn . untypeNoFetch
 
+-- | Close PreparedStatement. Useful for connection pooling cases.
+finish :: PreparedStatement p a -> IO ()
+finish = HDBC.finish . prepared
+
+-- | Bracketed prepare operation.
+--   Unsafely make Typed prepared statement.
+withUnsafePrepare :: IConnection conn
+                  => conn   -- ^ Database connection
+                  -> String -- ^ Raw SQL String
+                  -> (PreparedStatement p a -> IO b)
+                  -> IO b
+withUnsafePrepare conn qs =
+  bracket (unsafePrepare conn qs) finish
+
+-- | Bracketed prepare operation.
+--   Generalized prepare inferred from 'UntypeableNoFetch' instance.
+withPrepareNoFetch :: (UntypeableNoFetch s, IConnection conn)
+                   => conn
+                   -> s p
+                   -> (PreparedStatement p () -> IO a)
+                   -> IO a
+withPrepareNoFetch conn s =
+  bracket (prepareNoFetch conn s) finish
+
 -- | Typed operation to bind parameters.
 bind' :: RecordToSql SqlValue p -- ^ Proof object to convert from parameter type 'p' into 'SqlValue' list.
       -> PreparedStatement p a  -- ^ Prepared query to bind to
@@ -111,7 +138,7 @@
            -> s a
            -> a
            -> IO Integer
-runNoFetch conn s p = prepareNoFetch conn s >>= (`runPreparedNoFetch` p)
+runNoFetch conn s p = withPrepareNoFetch conn s (`runPreparedNoFetch` p)
 
 -- | Prepare and run it against each parameter list.
 mapNoFetch :: (UntypeableNoFetch s, IConnection conn, ToSql SqlValue a)
@@ -119,6 +146,5 @@
            -> s a
            -> [a]
            -> IO [Integer]
-mapNoFetch conn s rs = do
-  ps <- prepareNoFetch conn s
-  mapM (runPreparedNoFetch ps) rs
+mapNoFetch conn s rs =
+  withPrepareNoFetch conn s (\ps -> mapM (runPreparedNoFetch ps) rs)
diff --git a/src/Database/HDBC/Record/Update.hs b/src/Database/HDBC/Record/Update.hs
--- a/src/Database/HDBC/Record/Update.hs
+++ b/src/Database/HDBC/Record/Update.hs
@@ -12,7 +12,7 @@
 -- This module provides typed 'Update' running sequence
 -- which intermediate structres are typed.
 module Database.HDBC.Record.Update (
-  PreparedUpdate, prepare, prepareUpdate,
+  PreparedUpdate, prepare, prepareUpdate, withPrepareUpdate,
 
   runPreparedUpdate, runUpdate, mapUpdate
   ) where
@@ -23,7 +23,7 @@
 import Database.Record (ToSql)
 
 import Database.HDBC.Record.Statement
-  (prepareNoFetch, PreparedStatement, runPreparedNoFetch, runNoFetch, mapNoFetch)
+  (prepareNoFetch, withPrepareNoFetch, PreparedStatement, runPreparedNoFetch, runNoFetch, mapNoFetch)
 
 
 -- | Typed prepared update type.
@@ -42,6 +42,14 @@
               -> Update p
               -> IO (PreparedUpdate p)
 prepareUpdate =  prepare
+
+-- | Bracketed prepare operation.
+withPrepareUpdate :: IConnection conn
+                  => conn
+                  -> Update p
+                  -> (PreparedUpdate p -> IO a)
+                  -> IO a
+withPrepareUpdate = withPrepareNoFetch
 
 -- | Bind parameters, execute statement and get execution result.
 runPreparedUpdate :: ToSql SqlValue p