packages feed

Takusen 0.8.3 → 0.8.4

raw patch · 82 files changed

+42790/−290 lines, 82 filesdep +QuickCheckdep +Takusendep ~basesetup-changednew-component:exe:miniunit_testsnew-component:exe:takusen_testsbinary-added

Dependencies added: QuickCheck, Takusen

Dependency ranges changed: base

Files

+ Control/Exception/Extensible.hs view
@@ -0,0 +1,718 @@+-------------------------
+-- | 
+-- Module      :  Control.Exception
+-- Copyright   :  (c) The University of Glasgow 2001
+-- License     :  BSD-style (see the file LICENSE)
+-- 
+-- Maintainer  :  libraries@haskell.org
+-- Stability   :  experimental
+-- Portability :  non-portable (uses ExistentialQuantification and DeriveDataTypeable)
+--
+-- This module provides the extensible exceptions API for raising and catching both
+-- built-in and user-defined exceptions.
+-- 
+-- For newer versions of GHC (>=6.9), this package re-exports 'Control.Exception'.  
+-- Otherwise, it provides a compatibility layer around the previous version of the 
+-- extensions API.
+
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE ExistentialQuantification #-}
+{-# LANGUAGE DeriveDataTypeable #-}
+
+#ifdef USE_NEW_EXCEPTIONS
+module Control.Exception.Extensible (module Control.Exception) where
+
+import Control.Exception hiding (blocked)
+
+#else
+module Control.Exception.Extensible (
+    -- * The Exception type
+    SomeException(..),
+    Exception(..),
+    E.IOException,
+    E.ArithException(..),
+    E.ArrayException(..),
+    AssertionFailed(..),
+    E.AsyncException(..),
+    NonTermination(..),
+    NestedAtomically(..),
+    ExitCode(..),
+    BlockedOnDeadMVar(..),
+    BlockedIndefinitely(..),
+    Deadlock(..),
+    NoMethodError(..),
+    PatternMatchFail(..),
+    RecConError(..),
+    RecSelError(..),
+    RecUpdError(..),
+    ErrorCall(..),
+    
+    -- * Throwing exceptions
+    throwIO,
+    throw,
+    ioError,
+    throwTo,
+    -- * Catching Exceptions
+
+    -- |There are several functions for catching and examining
+    -- exceptions; all of them may only be used from within the
+    -- 'IO' monad.
+
+    -- ** The @catch@ functions
+    catch,     -- :: IO a -> (Exception -> IO a) -> IO a
+    catches, Handler(..),
+    catchJust, -- :: (Exception -> Maybe b) -> IO a -> (b -> IO a) -> IO a
+
+    -- ** The @handle@ functions
+    handle,    -- :: (Exception -> IO a) -> IO a -> IO a
+    handleJust,-- :: (Exception -> Maybe b) -> (b -> IO a) -> IO a -> IO a
+
+    -- ** The @try@ functions
+    try,       -- :: IO a -> IO (Either Exception a)
+    tryJust,   -- :: (Exception -> Maybe b) -> a    -> IO (Either b a)
+    onException,
+
+    -- ** The @evaluate@ function
+    E.evaluate,  -- :: a -> IO a
+
+    -- ** The @mapException@ function
+    mapException,           -- :: (Exception -> Exception) -> a -> a
+
+    -- * Asynchronous Exceptions
+
+    -- $async
+
+    -- ** Asynchronous exception control
+
+    -- |The following two functions allow a thread to control delivery of
+    -- asynchronous exceptions during a critical region.
+    
+    E.block,
+    E.unblock,
+
+    -- *** Applying @block@ to an exception handler
+
+    -- $block_handler
+
+    -- *** Interruptible operations
+
+    -- $interruptible
+
+    -- * Assertions
+
+    assert,      
+
+    -- * Utilities
+    bracket,
+    bracket_,
+    bracketOnError,
+    finally
+    ) where
+
+import Prelude hiding (catch)
+import Control.Concurrent hiding (throwTo)
+import qualified Control.Exception as E
+import Data.Dynamic
+import Data.Typeable
+import System.Exit
+import System.IO.Unsafe(unsafePerformIO)
+
+class (Typeable e, Show e) => Exception e where
+    toException   :: e -> SomeException
+    fromException :: SomeException -> Maybe e
+
+    toException = SomeException
+    fromException (SomeException e) = cast e
+
+data SomeException = forall e . Exception e => SomeException e
+    deriving Typeable
+
+instance Show SomeException where
+    showsPrec p (SomeException e) = showsPrec p e
+
+instance Exception SomeException where
+    toException se = se
+    fromException = Just
+
+mkOldException :: Exception e => e -> E.Exception
+mkOldException e = let e' = toException e
+          in case fromException e' of
+             Just e'' -> -- If the exception is actually a legacy exception
+                         -- then throw it directly so the legacy functions
+                         -- catch it as they expect
+                         e''
+             Nothing -> -- Otherwise, throw it as a dynamic
+                        E.DynException (toDyn e')
+
+throw :: Exception e => e -> a
+throw e = E.throw (mkOldException e)
+
+throwIO :: Exception e => e -> IO a
+throwIO e = E.throwIO (mkOldException e)
+
+throwTo :: Exception e => ThreadId -> e -> IO ()
+throwTo tid e = E.throwTo tid (mkOldException e)
+
+-----------------------------------------------------------------------------
+-- Catching exceptions
+
+-- |This is the simplest of the exception-catching functions.  It
+-- takes a single argument, runs it, and if an exception is raised
+-- the \"handler\" is executed, with the value of the exception passed as an
+-- argument.  Otherwise, the result is returned as normal.  For example:
+--
+-- >   catch (openFile f ReadMode)
+-- >       (\e -> hPutStr stderr ("Couldn't open "++f++": " ++ show e))
+--
+-- For catching exceptions in pure (non-'IO') expressions, see the
+-- function 'evaluate'.
+--
+-- Note that due to Haskell\'s unspecified evaluation order, an
+-- expression may return one of several possible exceptions: consider
+-- the expression @error \"urk\" + 1 \`div\` 0@.  Does
+-- 'catch' execute the handler passing
+-- @ErrorCall \"urk\"@, or @ArithError DivideByZero@?
+--
+-- The answer is \"either\": 'catch' makes a
+-- non-deterministic choice about which exception to catch.  If you
+-- call it again, you might get a different exception back.  This is
+-- ok, because 'catch' is an 'IO' computation.
+--
+-- Note that 'catch' catches all types of exceptions, and is generally
+-- used for \"cleaning up\" before passing on the exception using
+-- 'throwIO'.  It is not good practice to discard the exception and
+-- continue, without first checking the type of the exception (it
+-- might be a 'ThreadKilled', for example).  In this case it is usually better
+-- to use 'catchJust' and select the kinds of exceptions to catch.
+--
+-- Also note that the "Prelude" also exports a function called
+-- 'Prelude.catch' with a similar type to 'Control.Exception.catch',
+-- except that the "Prelude" version only catches the IO and user
+-- families of exceptions (as required by Haskell 98).
+--
+-- We recommend either hiding the "Prelude" version of 'Prelude.catch'
+-- when importing "Control.Exception":
+--
+-- > import Prelude hiding (catch)
+--
+-- or importing "Control.Exception" qualified, to avoid name-clashes:
+--
+-- > import qualified Control.Exception as C
+--
+-- and then using @C.catch@
+--
+catch   :: Exception e
+        => IO a         -- ^ The computation to run
+        -> (e -> IO a)  -- ^ Handler to invoke if an exception is raised
+        -> IO a
+catch io handler = io `E.catch` handler'
+    where handler' e = case fromException (toException e) of
+                       Just e' ->
+                           -- Handle the case where e == E.Exception,
+                           -- or one of the types that make up E.Exception
+                           handler e'
+                       Nothing ->
+                           case e of
+                           E.DynException dyn ->
+                               case fromDynamic dyn of
+                               Just (SomeException exc) ->
+                                   case cast exc of
+                                   Just e' ->
+                                       -- Handle the case where we have
+                                       -- a new exception type encoded
+                                       -- as a Dynamic
+                                       handler e'
+                                   Nothing -> E.throw e
+                               Nothing -> E.throw e
+                           _ -> E.throw e
+
+-- | When you want to acquire a resource, do some work with it, and
+-- then release the resource, it is a good idea to use 'bracket',
+-- because 'bracket' will install the necessary exception handler to
+-- release the resource in the event that an exception is raised
+-- during the computation.  If an exception is raised, then 'bracket' will
+-- re-raise the exception (after performing the release).
+--
+-- A common example is opening a file:
+--
+-- > bracket
+-- >   (openFile "filename" ReadMode)
+-- >   (hClose)
+-- >   (\handle -> do { ... })
+--
+-- The arguments to 'bracket' are in this order so that we can partially apply
+-- it, e.g.:
+--
+-- > withFile name mode = bracket (openFile name mode) hClose
+--
+bracket
+        :: IO a         -- ^ computation to run first (\"acquire resource\")
+        -> (a -> IO b)  -- ^ computation to run last (\"release resource\")
+        -> (a -> IO c)  -- ^ computation to run in-between
+        -> IO c         -- returns the value from the in-between computation
+bracket before after thing =
+  E.block (do
+    a <- before
+    r <- E.unblock (thing a) `onException` after a
+    after a
+    return r
+ )
+
+onException :: IO a -> IO b -> IO a
+onException io what = io `catch` \e -> do what
+                                          throw (e :: SomeException)
+
+block, unblock :: IO a -> IO a
+block = E.block
+unblock = E.unblock
+
+-- | A specialised variant of 'bracket' with just a computation to run
+-- afterward.
+--
+finally :: IO a         -- ^ computation to run first
+        -> IO b         -- ^ computation to run afterward (even if an exception
+                        -- was raised)
+        -> IO a         -- returns the value from the first computation
+a `finally` sequel =
+  E.block (do
+    r <- E.unblock a `onException` sequel
+    sequel
+    return r
+  )
+
+-- | A variant of 'bracket' where the return value from the first computation
+-- is not required.
+bracket_ :: IO a -> IO b -> IO c -> IO c
+bracket_ before after thing = bracket before (const after) (const thing)
+
+-- | Like bracket, but only performs the final action if there was an
+-- exception raised by the in-between computation.
+bracketOnError
+        :: IO a         -- ^ computation to run first (\"acquire resource\")
+        -> (a -> IO b)  -- ^ computation to run last (\"release resource\")
+        -> (a -> IO c)  -- ^ computation to run in-between
+        -> IO c         -- returns the value from the in-between computation
+bracketOnError before after thing =
+  block (do
+    a <- before
+    unblock (thing a) `onException` after a
+  )
+
+assert :: Bool -> a -> a
+assert True x = x
+assert False _ = throw (AssertionFailed "")
+
+-- | The function 'catchJust' is like 'catch', but it takes an extra
+-- argument which is an /exception predicate/, a function which
+-- selects which type of exceptions we\'re interested in.
+--
+-- >   result <- catchJust errorCalls thing_to_try handler
+--
+-- Any other exceptions which are not matched by the predicate
+-- are re-raised, and may be caught by an enclosing
+-- 'catch' or 'catchJust'.
+catchJust
+        :: Exception e
+        => (e -> Maybe b)         -- ^ Predicate to select exceptions
+        -> IO a                   -- ^ Computation to run
+        -> (b -> IO a)            -- ^ Handler
+        -> IO a
+catchJust p a handler = catch a handler'
+  where handler' e = case p e of
+                        Nothing -> throw e
+                        Just b  -> handler b
+
+-- | A version of 'catch' with the arguments swapped around; useful in
+-- situations where the code for the handler is shorter.  For example:
+--
+-- >   do handle (\e -> exitWith (ExitFailure 1)) $
+-- >      ...
+handle     :: Exception e => (e -> IO a) -> IO a -> IO a
+handle     =  flip catch
+
+-- | A version of 'catchJust' with the arguments swapped around (see
+-- 'handle').
+handleJust :: Exception e => (e -> Maybe b) -> (b -> IO a) -> IO a -> IO a
+handleJust p =  flip (catchJust p)
+
+-----------------------------------------------------------------------------
+-- 'mapException'
+
+-- | This function maps one exception into another as proposed in the
+-- paper \"A semantics for imprecise exceptions\".
+
+-- Notice that the usage of 'unsafePerformIO' is safe here.
+
+mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
+mapException f v = unsafePerformIO (catch (E.evaluate v)
+                                          (\x -> throw (f x)))
+
+-----------------------------------------------------------------------------
+-- 'try' and variations.
+
+-- | Similar to 'catch', but returns an 'Either' result which is
+-- @('Right' a)@ if no exception was raised, or @('Left' e)@ if an
+-- exception was raised and its value is @e@.
+--
+-- >  try a = catch (Right `liftM` a) (return . Left)
+--
+-- Note: as with 'catch', it is only polite to use this variant if you intend
+-- to re-throw the exception after performing whatever cleanup is needed.
+-- Otherwise, 'tryJust' is generally considered to be better.
+--
+-- Also note that "System.IO.Error" also exports a function called
+-- 'System.IO.Error.try' with a similar type to 'Control.Exception.try',
+-- except that it catches only the IO and user families of exceptions
+-- (as required by the Haskell 98 @IO@ module).
+
+try :: Exception e => IO a -> IO (Either e a)
+try a = catch (a >>= \ v -> return (Right v)) (\e -> return (Left e))
+
+-- | A variant of 'try' that takes an exception predicate to select
+-- which exceptions are caught (c.f. 'catchJust').  If the exception
+-- does not match the predicate, it is re-thrown.
+tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO (Either b a)
+tryJust p a = do
+  r <- try a
+  case r of
+        Right v -> return (Right v)
+        Left  e -> case p e of
+                        Nothing -> throw e
+                        Just b  -> return (Left b)
+
+
+-------------
+
+
+
+data Handler a = forall e . Exception e => Handler (e -> IO a)
+
+catches :: IO a -> [Handler a] -> IO a
+catches io handlers = io `catch` catchesHandler handlers
+
+catchesHandler :: [Handler a] -> SomeException -> IO a
+catchesHandler handlers e = foldr tryHandler (throw e) handlers
+    where tryHandler (Handler handler) res
+              = case fromException e of
+                Just e' -> handler e'
+                Nothing -> res
+
+
+-- -----------------------------------------------------------------------------
+-- Asynchronous exceptions
+
+{- $async
+
+ #AsynchronousExceptions# Asynchronous exceptions are so-called because they arise due to
+external influences, and can be raised at any point during execution.
+'StackOverflow' and 'HeapOverflow' are two examples of
+system-generated asynchronous exceptions.
+
+The primary source of asynchronous exceptions, however, is
+'throwTo':
+
+>  throwTo :: ThreadId -> Exception -> IO ()
+
+'throwTo' (also 'throwDynTo' and 'Control.Concurrent.killThread') allows one
+running thread to raise an arbitrary exception in another thread.  The
+exception is therefore asynchronous with respect to the target thread,
+which could be doing anything at the time it receives the exception.
+Great care should be taken with asynchronous exceptions; it is all too
+easy to introduce race conditions by the over zealous use of
+'throwTo'.
+-}
+
+{- $block_handler
+There\'s an implied 'block' around every exception handler in a call
+to one of the 'catch' family of functions.  This is because that is
+what you want most of the time - it eliminates a common race condition
+in starting an exception handler, because there may be no exception
+handler on the stack to handle another exception if one arrives
+immediately.  If asynchronous exceptions are blocked on entering the
+handler, though, we have time to install a new exception handler
+before being interrupted.  If this weren\'t the default, one would have
+to write something like
+
+>      block (
+>           catch (unblock (...))
+>                      (\e -> handler)
+>      )
+
+If you need to unblock asynchronous exceptions again in the exception
+handler, just use 'unblock' as normal.
+
+Note that 'try' and friends /do not/ have a similar default, because
+there is no exception handler in this case.  If you want to use 'try'
+in an asynchronous-exception-safe way, you will need to use
+'block'.
+-}
+
+{- $interruptible
+
+Some operations are /interruptible/, which means that they can receive
+asynchronous exceptions even in the scope of a 'block'.  Any function
+which may itself block is defined as interruptible; this includes
+'Control.Concurrent.MVar.takeMVar'
+(but not 'Control.Concurrent.MVar.tryTakeMVar'),
+and most operations which perform
+some I\/O with the outside world.  The reason for having
+interruptible operations is so that we can write things like
+
+>      block (
+>         a <- takeMVar m
+>         catch (unblock (...))
+>               (\e -> ...)
+>      )
+
+if the 'Control.Concurrent.MVar.takeMVar' was not interruptible,
+then this particular
+combination could lead to deadlock, because the thread itself would be
+blocked in a state where it can\'t receive any asynchronous exceptions.
+With 'Control.Concurrent.MVar.takeMVar' interruptible, however, we can be
+safe in the knowledge that the thread can receive exceptions right up
+until the point when the 'Control.Concurrent.MVar.takeMVar' succeeds.
+Similar arguments apply for other interruptible operations like
+'System.IO.openFile'.
+-}
+
+
+----------------------------------------------------------------------
+-- Exception instance for the legacy Exception type
+
+instance Exception E.Exception
+
+----------------------------------------------------------------------
+-- The new Exception types. These need to map to/from E.Exception so
+-- that uses of legacy catch/throw functions work.
+
+----
+
+instance Exception E.ArithException where
+    toException ae = toException (E.ArithException ae)
+    fromException (SomeException e) = case cast e of
+                                      Just (E.ArithException ae) ->
+                                         Just ae
+                                      _ -> Nothing
+----
+
+instance Exception E.ArrayException where
+    toException ae = toException (E.ArrayException ae)
+    fromException (SomeException e) = case cast e of
+                                      Just (E.ArrayException ae) ->
+                                          Just ae
+                                      _ -> Nothing
+
+----
+
+data AssertionFailed = AssertionFailed String
+    deriving Typeable
+
+instance Exception AssertionFailed where
+    toException (AssertionFailed str) = toException (E.AssertionFailed str)
+    fromException (SomeException e) = case cast e of
+                                      Just (E.AssertionFailed str) ->
+                                          Just (AssertionFailed str)
+                                      _ -> Nothing
+
+instance Show AssertionFailed where
+    showsPrec _ (AssertionFailed err) = showString err
+
+-----
+
+instance Exception E.AsyncException where
+    toException ae = toException (E.AsyncException ae)
+    fromException (SomeException e) = case cast e of
+                                      Just (E.AsyncException ae) ->
+                                          Just ae
+                                      _ -> Nothing
+
+----
+
+data BlockedOnDeadMVar = BlockedOnDeadMVar
+    deriving Typeable
+
+instance Exception BlockedOnDeadMVar where
+    toException BlockedOnDeadMVar = toException (E.BlockedOnDeadMVar)
+    fromException (SomeException e) = case cast e of
+                                      Just E.BlockedOnDeadMVar ->
+                                          Just BlockedOnDeadMVar
+                                      _ -> Nothing
+instance Show BlockedOnDeadMVar where
+    showsPrec n BlockedOnDeadMVar = showsPrec n E.BlockedOnDeadMVar
+
+----
+
+data BlockedIndefinitely = BlockedIndefinitely
+    deriving Typeable
+
+instance Exception BlockedIndefinitely where
+    toException BlockedIndefinitely = toException E.BlockedIndefinitely
+    fromException (SomeException e) = case cast e of
+                                      Just E.BlockedIndefinitely ->
+                                          Just BlockedIndefinitely
+                                      _ -> Nothing
+
+instance Show BlockedIndefinitely where
+    showsPrec n BlockedIndefinitely = showsPrec n E.BlockedIndefinitely
+
+----
+
+data NestedAtomically = NestedAtomically
+    deriving Typeable
+
+instance Exception NestedAtomically where
+    toException NestedAtomically = toException E.NestedAtomically
+    fromException (SomeException e) = case cast e of
+                                    Just E.NestedAtomically ->
+                                        Just NestedAtomically
+                                    _ -> Nothing
+
+instance Show NestedAtomically where
+    showsPrec n NestedAtomically = showsPrec n E.NestedAtomically
+
+----
+
+data Deadlock = Deadlock
+    deriving Typeable
+
+instance Exception Deadlock where
+    toException Deadlock = toException E.Deadlock
+    fromException (SomeException e) = case cast e of
+                                      Just E.Deadlock ->
+                                          Just Deadlock
+                                      _ -> Nothing
+
+instance Show Deadlock where
+    showsPrec n Deadlock = showsPrec n E.Deadlock
+
+-----
+
+data ErrorCall = ErrorCall String
+    deriving Typeable
+
+instance Exception ErrorCall where
+    toException (ErrorCall str) = toException (E.ErrorCall str)
+    fromException (SomeException e) = case cast e of
+                                      Just (E.ErrorCall str) ->
+                                          Just (ErrorCall str)
+                                      _ -> Nothing
+
+instance Show ErrorCall where
+    showsPrec _ (ErrorCall err) = showString err
+
+-----
+
+instance Typeable ExitCode where
+    typeOf _ = mkTyConApp (mkTyCon "ExitCode") []
+
+instance Exception ExitCode where
+    toException ee = toException (E.ExitException ee)
+    fromException (SomeException e) = case cast e of
+                                      Just (E.ExitException ee) ->
+                                          Just ee
+                                      _ -> Nothing
+-----
+
+instance Exception E.IOException where
+    toException ioe = toException (E.IOException ioe)
+    fromException (SomeException e) = case cast e of
+                                      Just (E.IOException ioe) ->
+                                          Just ioe
+                                      _ -> Nothing
+
+----
+
+data NoMethodError = NoMethodError String
+    deriving Typeable
+
+instance Exception NoMethodError where
+    toException (NoMethodError str) = toException (E.NoMethodError str)
+    fromException (SomeException e) = case cast e of
+                                      Just (E.NoMethodError str) ->
+                                          Just (NoMethodError str)
+                                      _ -> Nothing
+
+instance Show NoMethodError where
+    showsPrec _ (NoMethodError str) = showString str
+
+----
+
+data NonTermination = NonTermination
+    deriving Typeable
+
+instance Exception NonTermination where
+    toException NonTermination = toException E.NonTermination
+    fromException (SomeException e) = case cast e of
+                                      Just E.NonTermination ->
+                                          Just NonTermination
+                                      _ -> Nothing
+
+instance Show NonTermination where
+    showsPrec n NonTermination = showsPrec n E.NonTermination
+
+----
+
+data PatternMatchFail = PatternMatchFail String
+    deriving Typeable
+
+instance Exception PatternMatchFail where
+    toException (PatternMatchFail str) = toException (E.PatternMatchFail str)
+    fromException (SomeException e) = case cast e of
+                                      Just (E.PatternMatchFail str) ->
+                                          Just (PatternMatchFail str)
+                                      _ -> Nothing
+
+instance Show PatternMatchFail where
+    showsPrec _ (PatternMatchFail str) = showString str
+    
+
+----
+
+data RecConError = RecConError String
+    deriving Typeable
+
+instance Exception RecConError where
+    toException (RecConError str) = toException (E.RecConError str)
+    fromException (SomeException e) = case cast e of
+                                      Just (E.RecConError str) ->
+                                          Just (RecConError str)
+                                      _ -> Nothing
+
+instance Show RecConError where
+    showsPrec _ (RecConError str) = showString str
+    
+
+
+----
+
+data RecSelError = RecSelError String
+    deriving Typeable
+
+instance Exception RecSelError where
+    toException (RecSelError str) = toException (E.RecSelError str)
+    fromException (SomeException e) = case cast e of
+                                      Just (E.RecSelError str) ->
+                                          Just (RecSelError str)
+                                      _ -> Nothing
+
+instance Show RecSelError where
+    showsPrec _ (RecSelError str) = showString str
+
+----
+
+data RecUpdError = RecUpdError String
+    deriving Typeable
+
+instance Exception RecUpdError where
+    toException (RecUpdError str) = toException (E.RecUpdError str)
+    fromException (SomeException e) = case cast e of
+                                      Just (E.RecUpdError str) ->
+                                          Just (RecUpdError str)
+                                      _ -> Nothing
+
+instance Show RecUpdError where
+    showsPrec _ (RecUpdError str) = showString str
+
+
+#endif
+
Control/Exception/MonadIO.hs view
@@ -6,36 +6,21 @@ ) where
 
 import Control.Monad.Trans
-import Control.Exception
+import Control.Exception.Extensible
 import Control.Monad.Reader
 
-gtry :: (CaughtMonadIO m) => m b -> m (Either Exception b)
-gtry a = gcatch (liftM Right a) (return . Left)
 
-gtryJust :: (CaughtMonadIO m) =>
-  (Exception -> Maybe b) -> m b1 -> m (Either b b1)
-gtryJust p a = gcatchJust p (liftM Right a) (return . Left)
-
-gbracket :: (CaughtMonadIO m) =>
-  m t -> (t -> m a) -> (t -> m b) -> m b
-gbracket acq rel act = do
-  r <- acq
-  gcatch (do
-      v <- act r
-      rel r
-      return v
-    )
-    (\e -> rel r >> throw e)
-
-gfinally :: (CaughtMonadIO m) => m t -> m a -> m t
-gfinally a f = gbracket (return ()) (const f) (const a)
-
+gtry :: (Exception e, CaughtMonadIO m) => m b -> m (Either e b)
+gtryJust :: (Exception e, CaughtMonadIO m) => (e -> Maybe b) -> m b1 -> m (Either b b1)
 class MonadIO m => CaughtMonadIO m where
-  gcatch :: m a -> (Exception -> m a) -> m a
-  gcatchJust :: (Exception -> Maybe b) -> m a -> (b -> m a) -> m a
+  gcatch :: (Exception e) => m a -> (e -> m a) -> m a
+  gcatchJust :: (Exception e) => (e -> Maybe b) -> m a -> (b -> m a) -> m a
 
+gtry a = gcatch (liftM Right a) (return . Left)
+gtryJust p a = gcatchJust p (liftM Right a) (return . Left)
+
 instance CaughtMonadIO IO where
-  gcatch = Control.Exception.catch
+  gcatch = Control.Exception.Extensible.catch
   gcatchJust = catchJust
 
 instance CaughtMonadIO m => CaughtMonadIO (ReaderT a m) where
@@ -48,3 +33,16 @@          Just e' -> runReaderT (h e') r
        )
 
+gbracket :: (CaughtMonadIO m) =>
+  m t -> (t -> m a) -> (t -> m b) -> m b
+gbracket acq rel act = do
+  r <- acq
+  gcatch (do
+      v <- act r
+      rel r
+      return v
+    )
+    (\e@(SomeException _) -> rel r >> throw e)
+
+gfinally :: (CaughtMonadIO m) => m t -> m a -> m t
+gfinally a f = gbracket (return ()) (const f) (const a)
Database/Enumerator.lhs view
@@ -36,21 +36,20 @@ but their specific types and usage may differ between DBMS.
 
 
-Had better keep the old style, for older versions of GHC.
-
-> {-# OPTIONS -cpp #-}
 > {-# OPTIONS -fglasgow-exts #-}
-> {-# OPTIONS -fallow-overlapping-instances #-}
-> {-# OPTIONS -fallow-undecidable-instances #-}
-
-New style extension declarations.
-
 > {-# LANGUAGE CPP #-}
 > {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 > {-# LANGUAGE OverlappingInstances #-}
 > {-# LANGUAGE UndecidableInstances #-}
 
+> {-  LANGUAGE MultiParamTypeClasses #-}
+> {-  LANGUAGE RankNTypes #-}
+> {-  LANGUAGE FunctionalDependencies #-}
+> {-  LANGUAGE FlexibleInstances #-}
+> {-  LANGUAGE FlexibleContexts #-}
 
+
+
 > module Database.Enumerator
 >   (
 >     -- * Usage
@@ -120,9 +119,7 @@ > import Data.IORef
 > import Data.Time
 > import Control.Monad.Trans (liftIO)
-> import Control.Exception (throw, 
->            dynExceptions, throwDyn, bracket, Exception, finally)
-> import qualified Control.Exception (catch)
+> import Control.Exception.Extensible
 > import Control.Monad.Fix
 > import Control.Monad.Reader
 > import Control.Exception.MonadIO
@@ -146,10 +143,10 @@ monad.
 
 > catchDB :: CaughtMonadIO m => m a -> (IE.DBException -> m a) -> m a
-> catchDB action handler = gcatch action $ \e ->
->   maybe (throw e) handler (dynExceptions e >>= fromDynamic)
+> catchDB action handler = gcatch action $ handler
 
 
+
 |This simple handler reports the error to @stdout@ and swallows it
 i.e. it doesn't propagate.
 
@@ -288,8 +285,12 @@ >     -> IO (a, IE.ConnectA sess)
 > withContinuedSession (IE.ConnectA connecta) m = 
 >    do conn <- connecta  -- this invalidates connecta
+>       -- Note: if there was an error, then disconnect,
+>       -- but don't disconnect in the success case
+>       -- (the connecta action will raise an error if the
+>       -- connection is re-used).
 >       r <- runReaderT (unDBM m) conn
->            `Control.Exception.catch` (\e -> IE.disconnect conn >> throw e)
+>            `catch` (\e@(SomeException _) -> IE.disconnect conn >> throw e)
 >       -- make a new, one-shot connecta
 >       hasbeenused <- newIORef False
 >       let connecta = do
@@ -380,7 +381,7 @@ >        v <- action ps
 >        destroyStmt ps
 >        return v
->     ) (\e -> gcatch (destroyStmt ps >> throw e) (\_ -> throw e))
+>     ) (\e@(SomeException _) -> gcatch (destroyStmt ps >> throw e) (\e2@(SomeException _) -> throw e))
 
 
 Not exported.
@@ -493,7 +494,7 @@ > doQuery stmt iteratee seed = do
 >   (lFoldLeft, finalizer) <- doQueryMaker stmt iteratee
 >   gcatch (fix lFoldLeft iteratee seed)
->       (\e -> do
+>       (\e@(SomeException _) -> do
 >         finalizer
 >         liftIO (throw e)
 >       )
@@ -503,18 +504,14 @@ 
 > doQueryMaker stmt iteratee = do
 >     sess <- ask
->     query <- liftIO $ IE.makeQuery sess stmt
 >     -- if buffer allocation raises an exception
 >     -- (which it might) then we need to clean up the query object.
+>     query <- liftIO (IE.makeQuery sess stmt)
 >     buffers <- gcatch (allocBuffers query iteratee 1)
->       (\e -> do
->         liftIO (IE.destroyQuery query)
->         liftIO (throw e)
->       )
+>       (\e@(SomeException _) -> liftIO (IE.destroyQuery query >> throw e) )
 >     let
 >       finaliser =
->            liftIO (mapM_ (IE.freeBuffer query) buffers)
->         >> liftIO (IE.destroyQuery query)
+>         liftIO (mapM_ (IE.freeBuffer query) buffers >> IE.destroyQuery query)
 >       hFoldLeft self iteratee initialSeed = do
 >         let
 >           handle seed True = iterApply query buffers seed iteratee
@@ -642,7 +639,7 @@ >         v <- action
 >         commit
 >         return v
->       ) (\e -> rollback >> throw e )
+>       ) (\e@(SomeException _) -> rollback >> throw e )
 
 
 --------------------------------------------------------------------
Database/InternalEnumerator.lhs view
@@ -12,8 +12,10 @@ 
 Only the programmer for a new back-end needs to consult this file.
 
-> {-# OPTIONS -fglasgow-exts #-}
 
+> {-# LANGUAGE MultiParamTypeClasses #-}
+> {-# LANGUAGE FunctionalDependencies #-}
+
 > module Database.InternalEnumerator
 >   (
 >     -- * Session object.
@@ -35,8 +37,7 @@ >   ) where
 
 > import Data.Typeable
-> import Control.Exception (throw, catchDyn, 
->		    dynExceptions, throwDyn, throwIO, bracket, Exception)
+> import Control.Exception.Extensible (throw, Exception)
 > import qualified Control.Exception (catch)
 
 > data IsolationLevel =
@@ -87,10 +88,12 @@ >   | DBNoData
 >   deriving (Typeable, Show)
 
+> instance Exception DBException
+
 | Throw a DBException. It's just a type-specific 'Control.Exception.throwDyn'.
 
 > throwDB :: DBException -> a
-> throwDB = throwDyn
+> throwDB = throw
 
 
 --------------------------------------------------------------------
+ Database/MSSqlServer/MSSqlFunctions.lhs view
@@ -0,0 +1,93 @@+
+|
+Module      :  Database.MSSqlServer.MSSqlFunctions
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+ 
+Simple wrappers for MS Sql Server functions (FFI).
+ 
+ > -L"C:\Program Files\Common Files\System\Ole DB" -lsqloledb
+ 
+Don't forget to specify the header file location
+(or wherever your Sql Server installation resides):
+ 
+ > "-IC:\Program Files\Microsoft SQL Server\80\Tools\DevTools\Include"
+ 
+
+> {-# OPTIONS -ffi #-}
+> {-# OPTIONS -fglasgow-exts #-}
+
+From C:\WINDOWS\hh.exe "C:\Program Files\Microsoft SQL Server\80\Tools\Books\SQL80.col"
+ -- Compiling OLE DB Applications --
+"Most applications use wide character strings to make OLE DB function calls.
+If applications are using TCHAR variables, the application must include
+#define UNICODE in the application. It converts the TCHAR variables to 
+wide character strings."
+
+> {-# OPTIONS -optc-DUNICODE #-}
+
+Do we need this?
+ {-# OPTIONS -#include "windows.h" #-}
+
+> {-# OPTIONS -#include "sqloledb.h" #-}
+> {-# OPTIONS -#include "oledberr.h" #-}
+
+Don't need to explcitly include sqldb.h, as it's implied by the
+FFI foreign import declarations e.g.
+  > foreign import ccall "oledb.h dbinit" dbInit :: IO CString
+implies
+ {- # OPTIONS -#include "oledb.h" #-}
+
+
+> module Database.MSSqlServer.MSSqlFunctions where
+
+> import Foreign
+> import Foreign.C
+> import Control.Monad
+> import Control.Exception
+> import Data.Dynamic
+> import Data.Int
+> import Data.IORef
+
+
+
+> data MSSqlException = MSSqlException Int String
+>   deriving (Typeable, Eq)
+
+> instance Show MSSqlException where
+>   show (MSSqlException i s) = "MSSqlException " ++ (show i) ++ " " ++ s
+
+> makeEx :: CInt -> String -> MSSqlException
+> makeEx e msg = MSSqlException (fromIntegral e) msg
+
+> catchMSSql :: IO a -> (MSSqlException -> IO a) -> IO a
+> catchMSSql = catchDyn
+
+> throwMSSql :: MSSqlException -> a
+> throwMSSql = throwDyn
+
+> throwEx :: CInt -> String -> IO a
+> throwEx e msg = throwMSSql (makeEx e msg)
+
+> testForError :: CInt -> String -> a -> IO a
+> testForError rc msg retval = do
+>   case () of
+>     _ | rc == dbSUCCEED -> return retval
+>       | otherwise -> throwEx rc msg
+
+> errorOnNull :: Ptr b -> String -> a -> IO a
+> errorOnNull ptr msg retval = do
+>   if ptr == nullPtr
+>     then throwEx (-1 ) msg
+>     else return retval
+
+> cStr :: CStringLen -> CString
+> cStr = fst
+> cStrLen :: CStringLen -> CInt
+> cStrLen = fromIntegral . snd
+
+
+ foreign import ccall "sqldb.h dbinit" dbInit :: IO CString
+ Database/MSSqlServer/Test/Enumerator.lhs view
@@ -0,0 +1,32 @@+
+|
+Module      :  Database.MSSqlServer.Test.Enumerator
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+ 
+> {-# OPTIONS -fglasgow-exts -fallow-overlapping-instances #-}
+
+> module Database.MSSqlServer.Test.Enumerator (runTest) where
+
+> --import qualified Database.MSSqlServer.Enumerator as MSSql (connect, disconnect)
+> import qualified Database.MSSqlServer.Test.MSSqlFunctions as Low
+> import Database.Test.Enumerator as Enum
+> import Database.Test.Performance as Perf
+> import Database.Enumerator
+> import Control.Monad (when)
+
+
+> runTest :: Perf.ShouldRunTests -> [String] -> IO ()
+> runTest runPerf args = catchDB ( do
+>     let [user, pswd, dbname ] = args
+>     Low.runTest args
+>     {-
+>     sess <- MSSql.connect user pswd dbname
+>     Enum.runTests dateMSSql sess
+>     when (runPerf == Perf.RunTests) (Perf.runTests sess)
+>     MSSql.disconnect sess
+>     -}
+>   ) basicDBExceptionReporter
+ Database/MSSqlServer/Test/MSSqlFunctions.lhs view
@@ -0,0 +1,79 @@+
+|
+Module      :  Database.MSSqlServer.Test.MSSqlFunctions
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+
+ 
+> {-# OPTIONS -fglasgow-exts #-}
+
+
+> module Database.MSSqlServer.Test.MSSqlFunctions (runTest) where
+
+> import Prelude hiding (catch)
+> import Foreign
+> import Foreign.C
+> import Control.Monad
+> import Control.Exception
+> import Data.Dynamic
+> import Database.MSSqlServer.MSSqlFunctions
+> import System.Environment (getArgs)
+> import Test.HUnit
+> import Data.IORef
+
+
+> nullException = MSSqlException 0 ""
+
+> runTest :: [String] -> IO ()
+> runTest args = do
+>   ex <- newIORef nullException
+>   printIgnoreError ex $ do
+>     let [ usr, pwd, dbase, svr ] = args
+>     putStrLn "init"
+>     dbInit
+>     putStrLn "install error handler"
+>     enableErrorHandler ex
+>     putStrLn "open"
+>     sess <- open usr pwd dbase svr
+>     putStrLn "exec"
+>     execQuery sess "select 'hello'"
+>     putStrLn "fetch"
+>     rc <- fetchRow sess
+>     putStrLn "value"
+>     s <- colValString sess 1
+>     putStrLn s
+>     putStrLn "cancel"
+>     dbCancel sess
+>     putStrLn "close"
+>     dbClose sess
+>     putStrLn "exit"
+>     dbExit
+>     return ()
+
+
+> testlist db = TestList $ map (\t -> TestCase (t db))
+>   [ ]
+
+> ignoreError :: IO () -> IO ()
+> ignoreError action =
+>   catchMSSql action (\e -> return ())
+
+> printIgnoreError :: IORef MSSqlException -> IO () -> IO ()
+> printIgnoreError refex action = catchMSSql action 
+>     (\e -> do
+>       realEx <- readIORef refex
+>       let ex = if realEx == nullException then e else realEx
+>       putStrLn (show ex)
+>     )
+
+> printPropagateError :: IORef MSSqlException -> IO a -> IO a
+> printPropagateError refex action = catchMSSql action 
+>     (\e -> do
+>       realEx <- readIORef refex
+>       let ex = if realEx == nullException then e else realEx
+>       putStrLn (show ex)
+>       throwMSSql ex
+>     )
Database/ODBC/Enumerator.lhs view
@@ -10,16 +10,40 @@ ODBC implementation of Database.Enumerator.
 
 
+Notes on ODBC query processing:
+Query rebinding (i.e. prepared-stmt reuse) is awkward
+(at least for MS SQL Server):
+
+ * For a normal "select", when you are done fetching,
+   you must call closeCursor before you attempt to rebind.
+
+ * For a procedure call returning result-sets,
+   again (I think) you must call closeCursor before rebinding.
+   Don't call it until you've processed all result-sets,
+   because it will close all of them, including any unprocessed.
+
+ * For a procedure call that does not return a result-set,
+   closeCursor will raise an error.
+
+ * If you call closeCursor after preparing the stmt,
+   but before binding and executing, this will cause an error.
+   This means we can't simply call closeCursor before every bind.
+
+So when do we call closeCursor?
+Before binding, but only if the prepared-stmt object
+indicates that some rows have already been fetched.
+
+
 > {-# OPTIONS -fglasgow-exts #-}
-> {-# OPTIONS -fallow-undecidable-instances #-}
-> {-# OPTIONS -fallow-overlapping-instances #-}
+> {-# LANGUAGE OverlappingInstances #-}
+> {-# LANGUAGE UndecidableInstances #-}
 
 > module Database.ODBC.Enumerator
 >   ( Session, connect
->   , prepareStmt, preparePrefetch
+>   , prepareStmt
 >   , prepareQuery, prepareLargeQuery, prepareCommand
 >   , sql, sqlbind, prefetch, cmdbind
->   , Out(..)
+>   , Out(..), InfoDbmsName(..)
 >   , module Database.Enumerator
 >   )
 > where
@@ -31,7 +55,7 @@ > import Foreign.C
 > import Foreign.Storable (sizeOf)
 > import Control.Monad
-> import Control.Exception
+> import Control.Exception.Extensible (bracket)
 > import Database.ODBC.OdbcFunctions
 >   (EnvHandle, ConnHandle, StmtHandle, OdbcException(..), catchOdbc, throwOdbc)
 > import qualified Database.ODBC.OdbcFunctions as DBAPI
@@ -41,10 +65,13 @@ > import Data.Dynamic
 > import Data.IORef
 > import Data.Int
+> import Data.List (isPrefixOf)
 > import System.Time
 > import Data.Time
 
 
+> --debugStmt s = putStrLn s
+> debugStmt s = return ()
 
 --------------------------------------------------------------------
 -- ** API Wrappers
@@ -86,7 +113,7 @@ > stmtExecute stmt = convertEx (DBAPI.executeStmt stmt)
 
 > closeCursor :: StmtHandle -> IO ()
-> closeCursor stmt = convertEx (DBAPI.closeCursor stmt)
+> closeCursor stmt = debugStmt "closeCursor" >> convertEx (DBAPI.closeCursor stmt)
 
 > fetchRow :: StmtHandle -> IO Bool
 > fetchRow stmt = convertEx (DBAPI.fetch stmt)
@@ -94,7 +121,7 @@ > rowCount :: StmtHandle -> IO Int
 > rowCount stmt = convertEx (DBAPI.rowCount stmt)
 
-> freeStmt stmt = convertEx (DBAPI.freeStmt stmt)
+> freeStmt stmt = debugStmt "freeStmt" >> convertEx (DBAPI.freeStmt stmt)
 > freeConn conn = convertEx (DBAPI.freeConn conn)
 > freeEnv env = convertEx (DBAPI.freeEnv env)
 
@@ -131,6 +158,32 @@ >   (env, conn) <- connectDb connstr
 >   return (Session env conn)
 
+
+Note: the PostgreSQL ODBC driver only supports ReadCommitted
+and Serializable. It throws an error on other values.
+It'd be nicer if it just silently upgraded, but c'est la vie...
+
+Apparently MS SQL Server upgrades RepeatableRead to Serializable.
+Presumably the other modes are still supported.
+
+> isolationLevel ReadUncommitted = DBAPI.sqlTxnReadUncommitted
+> isolationLevel ReadCommitted = DBAPI.sqlTxnReadCommitted
+> isolationLevel RepeatableRead = DBAPI.sqlTxnRepeatableRead
+> isolationLevel Serialisable = DBAPI.sqlTxnSerializable
+> isolationLevel Serializable = DBAPI.sqlTxnSerializable
+
+> instance ISession Session where
+>   disconnect sess = do
+>     disconnectDb (connHandle sess)
+>     freeConn (connHandle sess)
+>     freeEnv (envHandle sess)
+>   -- With ODBC, transactions are implicitly started.
+>   beginTransaction sess isolation = do
+>     commitTrans (connHandle sess)
+>     setTransLevel (connHandle sess) (isolationLevel isolation)
+>   commit sess = commitTrans (connHandle sess)
+>   rollback sess = rollbackTrans (connHandle sess)
+
 --------------------------------------------------------------------
 -- Statements and Commands
 --------------------------------------------------------------------
@@ -153,10 +206,6 @@ >         liftM fromIntegral (rowCount stmt)
 >       )
 
-> instance Command BoundStmt Session where
->   executeCommand sess (BoundStmt pstmt) =
->     rowCount (stmtHandle pstmt)
-
 > instance Command StmtBind Session where
 >   executeCommand sess (StmtBind sqltext bas) = do
 >     let (PreparationA action) = prepareStmt' sqltext FreeManually
@@ -169,31 +218,18 @@ >         rowCount (stmtHandle pstmt)
 >       )
 
-Note: the PostgreSQL ODBC driver only supports ReadCommitted
-and Serializable. It throws an error on other values.
-It'd be nicer if it just silently upgraded, but c'est la vie...
+> instance Command BoundStmt Session where
+>   executeCommand sess (BoundStmt pstmt) =
+>     rowCount (stmtHandle pstmt)
 
-Apparently MS SQL Server upgrades RepeatableRead to Serializable.
-Presumably the other modes are still supported.
 
-> isolationLevel ReadUncommitted = DBAPI.sqlTxnReadUncommitted
-> isolationLevel ReadCommitted = DBAPI.sqlTxnReadCommitted
-> isolationLevel RepeatableRead = DBAPI.sqlTxnRepeatableRead
-> isolationLevel Serialisable = DBAPI.sqlTxnSerializable
-> isolationLevel Serializable = DBAPI.sqlTxnSerializable
+> data InfoDbmsName = InfoDbmsName
 
-> instance ISession Session where
->   disconnect sess = do
->     disconnectDb (connHandle sess)
->     freeConn (connHandle sess)
->     freeEnv (envHandle sess)
->   -- With ODBC, transactions are implicitly started.
->   beginTransaction sess isolation = do
->     commitTrans (connHandle sess)
->     setTransLevel (connHandle sess) (isolationLevel isolation)
->   commit sess = commitTrans (connHandle sess)
->   rollback sess = rollbackTrans (connHandle sess)
+> instance EnvInquiry InfoDbmsName Session String where
+>   inquire InfoDbmsName sess =
+>     liftM (map toLower) (DBAPI.getInfoDbmsName (connHandle sess))
 
+
 About stmtFreeWithQuery:
 
 We need to keep track of the scope of the PreparedStmtObj
@@ -211,37 +247,42 @@ separate types for the two types of prepared statement...
 
 > data StmtLifetime = FreeWithQuery | FreeManually
+>   deriving (Eq)
 
 > data PreparedStmtObj = PreparedStmtObj
 >   { stmtHandle :: StmtHandle
 >   , stmtLifetime :: StmtLifetime
+>   -- stmtBuffers are actually output bind buffers.
+>   -- we package them to look like ColumnBuffers
+>   -- (as created by allocBuffer) so that we can use them
+>   -- like ColumnBuffers.
+>   , stmtBuffers :: IORef [ColumnBuffer]
+>   , stmtFetched :: IORef Bool
 >   }
 
 > prepareStmt :: QueryString -> PreparationA Session PreparedStmtObj
 > prepareStmt (QueryString sqltext) = prepareStmt' sqltext FreeManually
 
 > prepareQuery :: QueryString -> PreparationA Session PreparedStmtObj
-> prepareQuery (QueryString sqltext) = prepareStmt' sqltext FreeManually
+> prepareQuery q = prepareStmt q
 
 > prepareLargeQuery :: Int -> QueryString -> PreparationA Session PreparedStmtObj
-> prepareLargeQuery _ (QueryString sqltext) = prepareStmt' sqltext FreeManually
+> prepareLargeQuery _ q = prepareStmt q
 
 > prepareCommand :: QueryString -> PreparationA Session PreparedStmtObj
-> prepareCommand (QueryString sqltext) = prepareStmt' sqltext FreeManually
-
-
-preparePrefetch is just here for interface consistency
-with Oracle and PostgreSQL.
-
-> preparePrefetch :: Int -> QueryString -> PreparationA Session PreparedStmtObj
-> preparePrefetch count (QueryString sqltext) =
->   prepareStmt' sqltext FreeManually
+> prepareCommand q = prepareStmt q
 
-> prepareStmt' sqltext free =
+> prepareStmt' sqltext lifetime =
 >   PreparationA (\sess -> do
 >     stmt <- stmtPrepare (connHandle sess) sqltext
->     return (PreparedStmtObj stmt free))
+>     newPreparedStmt stmt lifetime
+>     )
 
+> newPreparedStmt stmt lifetime = do
+>   b <- newIORef []
+>   f <- newIORef False
+>   return (PreparedStmtObj stmt lifetime b f)
+
 --------------------------------------------------------------------
 -- ** Binding
 --------------------------------------------------------------------
@@ -252,38 +293,46 @@ 
 > instance IPrepared PreparedStmtObj Session BoundStmt BindObj where
 >   bindRun sess pstmt bas action = do
+>     fetched <- readIORef (stmtFetched pstmt)
+>     when (fetched)
+>       (closeCursor (stmtHandle pstmt) >> writeIORef (stmtFetched pstmt) False)
 >     sequence_ (zipWith (\i (BindA ba) -> ba sess pstmt i) [1..] bas)
->     let stmt = stmtHandle pstmt
->     stmtExecute stmt
+>     stmtExecute (stmtHandle pstmt)
 >     action (BoundStmt pstmt)
->   destroyStmt sess pstmt = freeStmt (stmtHandle pstmt)
+>   destroyStmt sess pstmt = do
+>     -- Could free output bind buffers here, but for now we don't bother.
+>     -- They are ForeignPtrs, so we expect them to be GC'd.
+>     --buffers <- readIORef (stmtBuffers pstmt)
+>     --sequence_ (map (freeBindBuffer . colBuffer) buffers)
+>     freeStmt (stmtHandle pstmt)
 
+
 > instance DBBind (Maybe String) Session PreparedStmtObj BindObj where
 >   bindP val = makeBindAction val DBAPI.bindParamBuffer 0
 
 > instance DBBind (Out (Maybe String)) Session PreparedStmtObj BindObj where
->   bindP (Out val) = makeBindAction (DBAPI.InOutParam val) DBAPI.bindParamBuffer 16000
+>   bindP (Out val) = makeOutputBindAction (DBAPI.InOutParam val) DBAPI.bindParamBuffer 16000
 
 
 > instance DBBind (Maybe Int) Session PreparedStmtObj BindObj where
 >   bindP val = makeBindAction val DBAPI.bindParamBuffer 0
 
 > instance DBBind (Out (Maybe Int)) Session PreparedStmtObj BindObj where
->   bindP (Out val) = makeBindAction (DBAPI.InOutParam val) DBAPI.bindParamBuffer 0
+>   bindP (Out val) = makeOutputBindAction (DBAPI.InOutParam val) DBAPI.bindParamBuffer 0
 
 
 > instance DBBind (Maybe Double) Session PreparedStmtObj BindObj where
 >   bindP val = makeBindAction val DBAPI.bindParamBuffer 0
 
 > instance DBBind (Out (Maybe Double)) Session PreparedStmtObj BindObj where
->   bindP (Out val) = makeBindAction (DBAPI.InOutParam val) DBAPI.bindParamBuffer 0
+>   bindP (Out val) = makeOutputBindAction (DBAPI.InOutParam val) DBAPI.bindParamBuffer 0
 
 
 > instance DBBind (Maybe UTCTime) Session PreparedStmtObj BindObj where
 >   bindP val = makeBindAction val DBAPI.bindParamBuffer 0
 
 > instance DBBind (Out (Maybe UTCTime)) Session PreparedStmtObj BindObj where
->   bindP (Out val) = makeBindAction (DBAPI.InOutParam val) DBAPI.bindParamBuffer 0
+>   bindP (Out val) = makeOutputBindAction (DBAPI.InOutParam val) DBAPI.bindParamBuffer 0
 
 
 > instance DBBind (Maybe a) Session PreparedStmtObj BindObj
@@ -308,6 +357,15 @@ > makeBindAction val binder size = BindA (\ses st pos -> do
 >   convertEx (binder (stmtHandle st) pos val size >> return ()))
 
+> makeOutputBindAction val binder size = BindA (\ses st pos -> do
+>   convertEx (binder (stmtHandle st) pos val size >>= appendOutputBindBuffer st))
+
+> appendOutputBindBuffer stmt buffer = do
+>   buffers <- readIORef (stmtBuffers stmt)
+>   let colbuf = ColumnBuffer (1 + length buffers) buffer
+>   modifyIORef (stmtBuffers stmt) (++ [colbuf])
+
+
 --------------------------------------------------------------------
 -- ** Queries
 --------------------------------------------------------------------
@@ -354,43 +412,74 @@ >   makeQuery sess (QueryString sqltext) = makeQuery sess sqltext
 
 > instance Statement String Session Query where
->   makeQuery sess sqltext = do
->     let (PreparationA action) = prepareStmt' sqltext FreeWithQuery
->     pstmt <- action sess
->     stmtExecute (stmtHandle pstmt)
->     n <- newIORef 0
->     return (Query pstmt sess n)
+>   makeQuery sess sqltext = makeQuery sess (StmtBind sqltext [])
 
+> instance Statement (NextResultSet mark PreparedStmtObj) Session Query where
+>   makeQuery sess (NextResultSet (PreparedStmt pstmt)) = do
+>     -- If stmt buffers are present, then the first doQuery
+>     -- will have processed its results from there.
+>     -- So for tne next query, we want to clear the buffer list
+>     -- and start fetching from the stmt handle.
+>     -- This allows us to call stored procedures that return
+>     -- both output parameters and (multiple) result-sets.
+>     buffers <- readIORef (stmtBuffers pstmt)
+>     if null buffers
+>       then do
+>         more <- DBAPI.moreResults (stmtHandle pstmt)
+>         when (not more) (throwDB (DBError ("02", "000") (-1)
+>           "NextResultSet was used, but there are no more result-sets to process"))
+>         n <- newIORef 0
+>         return (Query pstmt sess n)
+>       else do
+>         writeIORef (stmtBuffers pstmt) []
+>         n <- newIORef 0
+>         return (Query pstmt sess n)
 
 > instance IQuery Query Session ColumnBuffer where
 >   destroyQuery query = do
->     closeCursor (stmtHandle (queryStmt query))
->     case stmtLifetime (queryStmt query) of
->       FreeWithQuery -> freeStmt (stmtHandle (queryStmt query))
->       FreeManually -> return ()
+>     let pstmt = queryStmt query
+>     when (stmtLifetime pstmt == FreeWithQuery)
+>       (freeStmt (stmtHandle pstmt))
 >   fetchOneRow query = do
->     moreRows <- fetchRow (stmtHandle (queryStmt query))
->     modifyIORef (queryCount query) (+1)
->     return moreRows
+>     let pstmt = queryStmt query
+>     -- Only call fetchRow if there are no bind output buffers
+>     -- If there are bind output buffers then assume this was a
+>     -- procedure call.
+>     -- In this case you will always get the same row over and over,
+>     -- so you'd better be careful with your iteratees
+>     buffers <- readIORef (stmtBuffers pstmt)
+>     if not (null buffers) then return True
+>       else do
+>         moreRows <- fetchRow (stmtHandle pstmt)
+>         writeIORef (stmtFetched pstmt) True
+>         modifyIORef (queryCount query) (+1)
+>         return moreRows
 >   currentRowNum q = readIORef (queryCount q)
 >   freeBuffer q buffer = return ()
 
 
-> nullIf :: Bool -> a -> Maybe a
-> nullIf test v = if test then Nothing else Just v
-
-> --bufferToString buffer =
-> --  convertEx (DBAPI.getUTF8StringFromBuffer (colBuffer buffer))
-
-
 > data ColumnBuffer = ColumnBuffer
 >   { colPos :: Int
 >   , colBuffer :: DBAPI.BindBuffer
 >   }
 
+In allocBuffer we decide to either
+ - create a new buffer - this is a real column buffer for a query - , or
+ - return an already-allocated output bind-buffer.
+
 > allocBuffer q pos size val = do
->   bindbuffer <- convertEx (DBAPI.bindColBuffer (stmtHandle (queryStmt q)) pos size val)
->   return (ColumnBuffer pos bindbuffer)
+>   let stmt = queryStmt q
+>   buffers <- readIORef (stmtBuffers stmt)
+>   if null buffers
+>     then do
+>       bindbuffer <- convertEx (DBAPI.bindColBuffer (stmtHandle stmt) pos size val)
+>       return (ColumnBuffer pos bindbuffer)
+>     else do
+>       if length buffers >= pos
+>         then return (buffers !! (pos - 1))
+>         else
+>           throwDB (DBError ("02", "000") (-1) ( "There are " ++ show (length buffers)
+>             ++ " output buffers, but you have asked for buffer " ++ show pos ))
 
 > buffer_pos q buffer = do
 >   row <- currentRowNum q
Database/ODBC/OdbcFunctions.hsc view
@@ -1,6 +1,6 @@ -{-# OPTIONS -ffi #-} {-# OPTIONS -fglasgow-exts #-}+{-# LANGUAGE CPP #-} {-# LANGUAGE ForeignFunctionInterface #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} @@ -34,7 +34,8 @@  module Database.ODBC.OdbcFunctions where -import Control.Exception+import Prelude hiding (catch)+import Control.Exception.Extensible import Control.Monad import Data.Dynamic import Data.Time@@ -43,6 +44,9 @@ import Foreign.C import Foreign.C.UTF8 +--debugStmt s = putStrLn s+debugStmt s = return ()+ data HandleObj = HandleObj type Handle = Ptr HandleObj data EnvObj = EnvObj@@ -320,16 +324,18 @@  instance Show OdbcException where   show (OdbcException i st s more) = "OdbcException "-    ++ (show i) ++ " " ++ st ++ " " ++ s -- ++ (concat (map showOdbcExMsg more))---- showOdbcExMsg (OdbcException i st s more) = s+    ++ (show i) ++ " " ++ st ++ " " ++ s+    -- Could print the entire chain of diag recs... is this a good idea?+    -- ++ (concat (map showOdbcExMsg more))+    --   where showOdbcExMsg (OdbcException i st s more) = s  catchOdbc :: IO a -> (OdbcException -> IO a) -> IO a-catchOdbc = catchDyn- throwOdbc :: OdbcException -> a-throwOdbc = throwDyn+instance Exception OdbcException+catchOdbc = catch+throwOdbc = throw + -- define SQL_SUCCEEDED(rc) (((rc)&(~1))==0) sqlSucceeded rc = rc == sqlRcSuccess || rc == sqlRcSuccessWithInfo @@ -340,15 +346,15 @@   allocaBytes 1025 $ \cstrMsg -> do   alloca $ \msgLenPtr -> do     rc <- sqlGetDiagRec htype handle row cstrState errorNumPtr cstrMsg 1024 msgLenPtr-    --putStrLn ("getDiagRec: rc=" ++ show rc)+    --debugStmt ("getDiagRec: rc=" ++ show rc)     case () of       _ | rc == sqlRcSuccess -> do           errnum <- peek errorNumPtr           state <- myPeekCStringLen (cstrState, 5)           msglen <- peek msgLenPtr-          --putStrLn ("getDiagRec: msglen=" ++ show msglen)+          --debugStmt ("getDiagRec: msglen=" ++ show msglen)           msg <- myPeekCStringLen (cstrMsg, fromIntegral msglen)-          --putStrLn ("getDiagRec: msg=" ++ msg)+          --debugStmt ("getDiagRec: msg=" ++ msg)           more <- getDiagRec retcode htype handle (row+1)           return ((OdbcException (fromIntegral errnum) state msg []) : more)         | rc == sqlRcNoData -> return []@@ -540,6 +546,9 @@ -- The OdbcBindBuffer class has a getData function which uses these, -- if you'd rather. +-- This function tests the null indicator first.+-- If the value is null, then there's no need to do the actual marshaling,+-- which is performed by the action passed in. getMaybeFromBuffer :: Storable a => Ptr SqlLen -> Ptr a -> (Ptr a -> SqlLen -> IO b) -> IO (Maybe b) getMaybeFromBuffer szptr bptr action = do   len <- peek szptr@@ -677,6 +686,7 @@  getCAStringFromBuffer :: BindBuffer -> IO (Maybe String) getCAStringFromBuffer buffer =+  -- FIXME also assume null-termed string?   testForNull buffer (\ptr len -> peekCAStringLen (castPtr ptr, fromIntegral len))  getCWStringFromBuffer :: BindBuffer -> IO (Maybe String)@@ -685,7 +695,11 @@  getUTF8StringFromBuffer :: BindBuffer -> IO (Maybe String) getUTF8StringFromBuffer buffer =-  testForNull buffer (\ptr len -> peekUTF8StringLen (castPtr ptr, fromIntegral len))+  testForNull buffer (\ptr len ->+    debugStmt ("getUTF8StringFromBuffer: size " ++ show len) >>+    --peekUTF8StringLen (castPtr ptr, fromIntegral len))+    -- assume null-termed string+    peekUTF8String (castPtr ptr))  getUtcTimeFromBuffer :: BindBuffer -> IO (Maybe UTCTime) getUtcTimeFromBuffer bindbuffer = do@@ -755,7 +769,8 @@   mem <- mallocBytes bufsz   copyBytes mem cstr (fromIntegral clen)   pokeByteOff mem (fromIntegral clen) (0 :: Word8)-  buffer <- wrapSizedBuffer mem (fromIntegral clen) bufsz+  --buffer <- wrapSizedBuffer mem (fromIntegral clen) bufsz+  buffer <- wrapSizedBuffer mem sqlNullTermedString bufsz   bindParam stmt pos direction sqlCTypeString sqlDTypeString (fromIntegral clen) 0 buffer   return buffer @@ -768,6 +783,7 @@  bindParamUTF8String :: StmtHandle -> Int -> SqlParamDirection -> Maybe String -> Int -> IO BindBuffer bindParamUTF8String stmt pos direction val sz =+  debugStmt ("bindParamUTF8String: " ++ show val ++ ", size " ++ show sz) >>   bindEncodedString stmt pos direction val withUTF8StringLen sz  bindParamCAString :: StmtHandle -> Int -> SqlParamDirection -> Maybe String -> Int -> IO BindBuffer@@ -858,6 +874,7 @@ -- Binding with class...  sizeOfMaybe :: forall a. Storable a => Maybe a -> Int+--sizeOfMaybe :: Storable a => Maybe a -> Int sizeOfMaybe _ = sizeOf ( undefined :: a ) -- H98 stylee... --sizeOfMaybe v@Nothing = sizeOfMaybe (asTypeOf (Just undefined) v)@@ -1059,7 +1076,7 @@   -> SqlSmallInt  -- ^ decimal digits (scale)   -> Ptr Buffer  -- ^ input+output buffer   -> SqlLen  -- ^ buffer size-  -> Ptr SqlLen -- ^ input+output data size, or -1 (SQL_NULL_DATA) for null+  -> Ptr SqlLen -- ^ input+output data size, SQL_NTS (-3), SQL_NULL_DATA (-1), or SQL_NO_TOTAL (-4)   -> IO SqlReturn  -- SQLRETURN SQL_API SQLExecute(SQLHSTMT);
+ Database/ODBC/Test/Enumerator.lhs view
@@ -0,0 +1,262 @@+
+|
+Module      :  Database.ODBC.Test.Enumerator
+Copyright   :  (c) 2007 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+
+
+> module Database.ODBC.Test.Enumerator (runTest) where
+
+> import qualified Database.ODBC.Test.OdbcFunctions as Low
+> import Database.ODBC.Enumerator
+> import Database.Test.Performance as Perf
+> import Database.Test.Enumerator
+> import Database.Util
+> import Control.Monad (liftM, when)
+> import Control.Monad.Trans (liftIO)
+> import Data.Char
+> import Test.MiniUnit
+
+
+> runTest :: Perf.ShouldRunTests -> [String] -> IO ()
+> runTest runPerf args = do
+>   let (dsn:_) = args
+>   Low.runTest args
+>   flip catchDB basicDBExceptionReporter $ do
+>     (r, conn1) <- withContinuedSession (connect dsn) (testBody runPerf)
+>     withSession conn1 testPartTwo
+
+> testBody :: Perf.ShouldRunTests -> DBM mark Session ()
+> testBody runPerf = do
+>   runFixture ODBCFunctions
+>   when (runPerf == Perf.RunTests) runPerformanceTests
+
+> testPartTwo :: DBM mark Session ()
+> testPartTwo = do
+>   makeFixture execDrop execDDL_
+>   destroyFixture execDDL_
+
+> runFixture :: DBLiteralValue a => a -> DBM mark Session ()
+> runFixture fns = do
+>   makeFixture execDrop execDDL_
+>   runTestTT "ODBC tests" (map (runOneTest fns) testList)
+>   destroyFixture execDDL_
+
+> runOneTest fns t = catchDB (t fns) (reportRethrowMsg "runOneTest ")
+
+> runPerformanceTests :: DBM mark Session ()
+> runPerformanceTests = do
+>   makeFixture execDrop execDDL_
+>   beginTransaction ReadCommitted
+>   runTestTT "ODBC performance tests" (map (flip catchDB reportRethrow)
+>     -- The PostgreSQL ODBC driver has genetric query optimisation disabled
+>     -- by default. This makes it really struggle with the query we use
+>     -- for performance testing - the memory used by the server process
+>     -- goes through the roof.
+>     [ timedSelect (prefetch 1 sqlRows2Power17 []) 4 (2^17)
+>     , timedSelect (prefetch 1000 sqlRows2Power17 []) 4 (2^17)
+>     , timedCursor (prefetch 1 sqlRows2Power17 []) 4 (2^17)
+>     , timedCursor (prefetch 1000 sqlRows2Power17 []) 4 (2^17)
+>     , timedSelect (prefetch 1000 sqlRows2Power20 []) 35 (2^20)
+>     ]
+>     )
+>   commit
+>   destroyFixture execDDL_
+
+
+-----------------------------------------------------------
+
+> selectNoRows _ = selectTest sqlNoRows iterNoRows expectNoRows
+
+> selectTerminatesEarly _ = selectTest sqlTermEarly iterTermEarly expectTermEarly
+
+> selectFloatsAndInts fns = selectTest (sqlFloatsAndInts fns) iterFloatsAndInts expectFloatsAndInts
+
+> selectNullString _ = selectTest sqlNullString iterNullString expectNullString
+
+> selectEmptyString _ = selectTest sqlEmptyString iterEmptyString expectEmptyString
+
+> selectUnhandledNull _ = catchDB ( do
+>       selectTest sqlUnhandledNull iterUnhandledNull expectUnhandledNull
+>       assertFailure sqlUnhandledNull
+>   ) (\e -> return () )
+
+
+
+> selectNullDate dateFn = selectTest (sqlNullDate dateFn) iterNullDate expectNullDate
+
+> selectCursor fns = actionCursor (sqlCursor fns)
+> selectExhaustCursor fns = actionExhaustCursor (sqlCursor fns)
+
+> selectBindString _ = actionBindString
+>     (prepareQuery (sql sqlBindString))
+>     [bindP "a2", bindP "b1"]
+
+> selectBindInt _ = actionBindInt
+>   (prepareQuery (sql sqlBindInt))
+>   [bindP (1::Int), bindP (2::Int)]
+
+
+> selectBindIntDoubleString _ = actionBindIntDoubleString
+>   (prefetch 1 sqlBindIntDoubleString [bindP (1::Int), bindP (2.2::Double), bindP "row 1", bindP (3::Int), bindP (4.4::Double), bindP "row 2"])
+
+> selectBindDate _ = actionBindDate
+>   (prefetch 1 sqlBindDate (map bindP expectBindDate))
+
+> selectBindBoundaryDates _ = actionBindBoundaryDatesLocal
+>   (prefetch 1 sqlBindBoundaryDates (map bindP expectBoundaryDatesLocal))
+
+> expectBoundaryDatesLocal =
+>   -- 1753 seems to be about the earliest year MS SQL Server supports.
+>   [ int64ToUTCTime   17530101000000
+>   , int64ToUTCTime   20010102000000
+>   , int64ToUTCTime   20010103000000
+>   , int64ToUTCTime   99991231000000
+>   ]
+> actionBindBoundaryDatesLocal stmt = do
+>   withTransaction Serialisable $ do
+>     actual <- doQuery stmt iterBindDate []
+>     assertEqual sqlBindBoundaryDates expectBoundaryDatesLocal actual
+
+
+> selectRebindStmt _ = actionRebind (prepareQuery (sql sqlRebind))
+>    [bindP (1::Int)] [bindP (2::Int)]
+
+> boundStmtDML _ = actionBoundStmtDML (prepareCommand (sql sqlBoundStmtDML))
+> boundStmtDML2 _ = do
+>   -- With MS SQL Server cannot use withTransaction with rollback/commit;
+>   -- if you explicitly end the transaction, then when withTransaction
+>   -- attempts to end it (with a commit, in the success case) then we
+>   -- get a "logic error".
+>   -- This differs from PostgreSQL and Oracle, who don't seem to care if
+>   -- you commit or rollback too many times.
+>   beginTransaction ReadCommitted
+>   count <- execDML (cmdbind sqlBoundStmtDML [bindP (100::Int), bindP "100"])
+>   rollback
+>   assertEqual sqlBoundStmtDML 1 count
+
+> polymorphicFetchTest _ = actionPolymorphicFetch
+>   (prefetch 1 sqlPolymorphicFetch [bindP expectPolymorphicFetch])
+
+> polymorphicFetchTestNull _ = actionPolymorphicFetchNull
+>   (prefetch 1 sqlPolymorphicFetchNull [])
+
+> exceptionRollback _ = actionExceptionRollback sqlInsertTest4 sqlExceptionRollback
+
+> iterateeMatchesResultSet _ = actionIterateeMatchesResultSet
+>   (prefetch 0 sqlIterateeMatchesResultSet [bindP (1::Int), bindP (2.2::Double), bindP "row 1", bindP (3::Int)])
+
+
+> dropFixtureMultiResultSet1 = "DROP VIEW t_whole"
+> makeFixtureMultiResultSet1 = "CREATE VIEW t_whole as"
+>   ++ " select 0 as n  union select 1"
+>   ++ " union select 2 union select 3"
+>   ++ " union select 4 union select 5"
+>   ++ " union select 6 union select 7"
+>   ++ " union select 8 union select 9"
+
+> dropFixtureMultiResultSet2 = "DROP VIEW t_natural"
+> makeFixtureMultiResultSet2 = "CREATE VIEW t_natural as"
+>   ++ " select n from"
+>   ++ " ( select t1.n + 10 * t10.n + 100 * t100.n as n"
+>   ++ "   from t_whole t1, t_whole t10, t_whole t100"
+>   ++ " ) t where n > 0"
+
+> dropFixtureMultiResultSet3 = "DROP PROCEDURE takusenTestProc"
+> makeFixtureMultiResultSet3 = "CREATE PROCEDURE takusenTestProc"
+>   ++ " AS BEGIN"
+>   ++ " SELECT n*n from t_natural where n < 10 order by 1 \n\n"
+>   ++ " SELECT n, n*n, n*n*n from t_natural where n < 10 order by 1 \n\n"
+>   ++ " END;"
+
+
+> selectMultiResultSet _ = do
+>   dbmsname <- liftM (map toLower) (inquire InfoDbmsName)
+>   when (dbmsname == "microsoft sql server") $ do
+>     execDrop dropFixtureMultiResultSet3
+>     execDrop dropFixtureMultiResultSet2
+>     execDrop dropFixtureMultiResultSet1
+>     execDDL_ makeFixtureMultiResultSet1
+>     execDDL_ makeFixtureMultiResultSet2
+>     execDDL_ makeFixtureMultiResultSet3
+>     withPreparedStatement (prepareCommand (sql "{call takusenTestProc}")) $ \pstmt -> do
+>     withBoundStatement pstmt [] $ \bstmt -> do
+>       result1 <- doQuery bstmt iterRS1 []
+>       assertEqual "selectMultiResultSet: RS1" [1,4,9,16,25,36,49,64,81] result1
+>       result2 <- doQuery (NextResultSet pstmt) iterRS2 []
+>       let expect = [(1,1,1),(2,4,8),(3,9,27),(4,16,64),(5,25,125),(6,36,216)
+>             ,(7,49,343),(8,64,512),(9,81,729)]
+>       assertEqual "selectMultiResultSet: RS2" expect result2
+>       return ()
+>     execDDL_ dropFixtureMultiResultSet3
+>     execDDL_ dropFixtureMultiResultSet2
+>     execDDL_ dropFixtureMultiResultSet1
+>   where
+>     iterRS1 :: (Monad m) => Int -> IterAct m [Int]
+>     iterRS1 i acc = result (acc ++ [i])
+>     iterRS2 :: (Monad m) => Int -> Int -> Int -> IterAct m [(Int, Int, Int)]
+>     iterRS2 i i2 i3 acc = result (acc ++ [(i, i2, i3)])
+
+
+> dropFixtureBindOutput = "DROP PROCEDURE takusenTestProc"
+> makeFixtureBindOutputSqlServer = "CREATE PROCEDURE takusenTestProc @x int output, @y varchar(200) output"
+>   ++ " AS BEGIN"
+>   ++ " declare @z varchar(200) \n\n"
+>   ++ " select @x = 2 * @x \n\n"
+>   ++ " select @z = 'output ' + @y + ' xxx' \n\n"
+>   ++ " select @y = @z \n\n"
+>   ++ " END;"
+
+> makeFixtureBindOutputOracle = "CREATE or replace PROCEDURE takusenTestProc(x in out number, y in out varchar)"
+>   ++ " AS BEGIN"
+>   ++ " x := x * 2;"
+>   ++ " y := 'output ' || y || ' xxx';"
+>   ++ " END;"
+
+> bindOutput _ = do
+>   dbmsname <- liftM (map toLower) (inquire InfoDbmsName)
+>   case dbmsname of
+>     "microsoft sql server" -> k makeFixtureBindOutputSqlServer
+>     "oracle" -> k makeFixtureBindOutputOracle
+>     _ -> return ()
+>   where
+>   k makeFixture = do
+>     execDrop dropFixtureBindOutput
+>     execDDL_ makeFixture
+>     let qry = sqlbind "{call takusenTestProc(?,?)}" [bindP (Out (1234::Int)), bindP (Out (Just "message"))]
+>     (x, s) <- doQuery qry iter undefined
+>     execDrop dropFixtureBindOutput
+>     assertEqual "bindOutput: int " 2468 x
+>     assertEqual "bindOutput: string " "output message" s
+>   iter :: (Monad m) => Int -> String -> IterAct m (Int, String)
+>   iter i s _ = return (Left (i, s))
+
+
+> testList :: DBLiteralValue a => [a -> DBM mark Session ()]
+> testList =
+>   selectNoRows :
+>   selectTerminatesEarly :
+>   selectFloatsAndInts :
+>   selectNullString :
+>   selectEmptyString :
+>   selectUnhandledNull :
+>   selectCursor :
+>   selectExhaustCursor :
+>   selectBindString :
+>   selectBindInt :
+>   selectBindIntDoubleString :
+>   selectBindDate :
+>   selectBindBoundaryDates :
+>   selectRebindStmt :
+>   boundStmtDML :
+>   boundStmtDML2 :
+>   polymorphicFetchTest :
+>   polymorphicFetchTestNull :
+>   exceptionRollback :
+>   iterateeMatchesResultSet :
+>   selectMultiResultSet :
+>   bindOutput :
+>   []
+ Database/ODBC/Test/OdbcFunctions.lhs view
@@ -0,0 +1,522 @@+
+|
+Module      :  Database.ODBC.Test.OdbcFunctions
+Copyright   :  (c) 2007 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+
+
+-- FIXME  add tests for moreResults
+
+> module Database.ODBC.Test.OdbcFunctions where
+
+> import Database.ODBC.OdbcFunctions
+> import Control.Exception.Extensible (finally)
+> import Control.Monad (liftM, when)
+> import Data.Char
+> import Data.List
+> import Data.Time
+> import Data.Word (Word8)
+> import Database.Util
+> import Test.MiniUnit
+> import Foreign.ForeignPtr (withForeignPtr)
+> import Foreign.Ptr (castPtr)
+> import Foreign.Storable (peek)
+> import Foreign.Marshal.Array (peekArray0, peekArray)
+> import Numeric (showHex)
+
+
+> ignoreError action =
+>   catchOdbc action (\e -> return undefined)
+
+> printIgnoreError action = catchOdbc action 
+>     (\e -> do
+>       putStrLn (show e)
+>       return undefined
+>     )
+
+> printPropagateError action = catchOdbc action 
+>     (\e -> do
+>       putStrLn (show e)
+>       throwOdbc e
+>       return undefined
+>     )
+
+> testCreateEnv = do
+>   env <- allocEnv
+>   freeEnv env
+
+> testCreateConn = do
+>   env <- allocEnv
+>   setOdbcVer env
+>   conn <- allocConn env
+>   freeConn conn
+>   freeEnv env
+
+> testConnect connstr = do
+>   env <- allocEnv
+>   setOdbcVer env
+>   conn <- allocConn env
+>   connstr <- connect conn connstr
+>   disconnect conn
+>   freeConn conn
+>   freeEnv env
+
+> createConn connstr = do
+>   env <- allocEnv
+>   setOdbcVer env
+>   conn <- allocConn env
+>   connstr <- connect conn connstr
+>   dbms <- getInfoDbmsName conn
+>   return (env, conn { connDbms = map toLower dbms } )
+
+> closeConn (env, conn) = do
+>   disconnect conn
+>   freeConn conn
+>   freeEnv env
+
+
+> createDual conn = do
+>   stmt <- allocStmt conn
+>   prepareStmt stmt "create table tdual (dummy varchar(1) primary key)"
+>   executeStmt stmt
+>   prepareStmt stmt "insert into tdual values ('X')"
+>   executeStmt stmt
+>   freeStmt stmt
+
+> dropDual conn = do
+>   stmt <- allocStmt conn
+>   prepareStmt stmt "drop table tdual"
+>   executeStmt stmt
+>   freeStmt stmt
+
+
+> testCreateStmt conn = do
+>   stmt <- allocStmt conn
+>   prepareStmt stmt "select 'x' from tdual"
+>   executeStmt stmt
+>   freeStmt stmt
+
+
+> testIsolationLevel conn = do
+>   -- For PostgreSQL this fails with:
+>   -- 206 HY009 Illegal parameter value for SQL_TXN_ISOLATION
+>   --setTxnIsolation conn sqlTxnReadUncommitted
+>   setTxnIsolation conn sqlTxnReadCommitted  -- This is OK
+>   -- For PostgreSQL this fails with:
+>   -- 206 HY009 Illegal parameter value for SQL_TXN_ISOLATION
+>   --setTxnIsolation conn sqlTxnRepeatableRead
+>   setTxnIsolation conn sqlTxnSerializable  -- This is OK
+
+
+Uses getData, rather than a buffer.
+
+> testFetchString conn = do
+>   stmt <- allocStmt conn
+>   let string1 = "abc" ++ map chr [0x000080, 0x0007FF, 0x00FFFF, 0x10FFFF]
+>   let string2 = "xyz" ++ map chr [0x000080, 0x0007FF, 0x00FFFF, 0x10FFFF]
+>   prepareStmt stmt ("select '" ++ string1
+>     ++ "' from tdual union select '" ++ string2 ++ "' from tdual order by 1")
+>   executeStmt stmt
+>   more <- fetch stmt
+>   s <- getDataUTF8String stmt 1
+>   assertEqual "testFetchString" (Just string1) s
+>   more <- fetch stmt
+>   s <- getDataUTF8String stmt 1
+>   assertEqual "testFetchString" (Just string2) s
+>   more <- fetch stmt
+>   assertBool "testFetchString: EOD" (not more)
+>   freeStmt stmt
+
+> testFetchStringWithBuffer conn = do
+>   stmt <- allocStmt conn
+>   let string1 = "abc" ++ map chr [0x000080, 0x0007FF, 0x00FFFF, 0x10FFFF]
+>   let string2 = "xyz" ++ map chr [0x000080, 0x0007FF, 0x00FFFF, 0x10FFFF]
+>   prepareStmt stmt ("select '" ++ string1
+>     ++ "' from tdual union select '" ++ string2 ++ "' from tdual order by 1")
+>   executeStmt stmt
+>   buffer <- bindColBuffer stmt 1 100 (Just "")
+>   more <- fetch stmt
+>   s <- getUTF8StringFromBuffer buffer
+>   assertEqual "testFetchStringWithBuffer" (Just string1) s
+>   more <- fetch stmt
+>   s <- getUTF8StringFromBuffer buffer
+>   assertEqual "testFetchStringWithBuffer" (Just string2) s
+>   more <- fetch stmt
+>   assertBool "testFetchStringWithBuffer: EOD" (not more)
+>   freeStmt stmt
+
+> testFetchInt conn = do
+>   stmt <- allocStmt conn
+>   prepareStmt stmt "select 101 from tdual"
+>   executeStmt stmt
+>   more <- fetch stmt
+>   s <- getData stmt 1
+>   let expect :: Int; expect = 101
+>   assertEqual "testFetchInt" (Just expect) s
+>   more <- fetch stmt
+>   assertBool "testFetchInt: EOD" (not more)
+>   freeStmt stmt
+
+> testFetchIntWithBuffer conn = do
+>   stmt <- allocStmt conn
+>   prepareStmt stmt "select 101 from tdual"
+>   executeStmt stmt
+>   buffer <- bindColBuffer stmt 1 0 (Just (0::Int))
+>   more <- fetch stmt
+>   s <- getFromBuffer buffer
+>   let expect :: Int; expect = 101
+>   assertEqual "testFetchInt" (Just expect) s
+>   more <- fetch stmt
+>   assertBool "testFetchInt: EOD" (not more)
+>   freeStmt stmt
+
+> testFetchDouble conn = do
+>   stmt <- allocStmt conn
+>   prepareStmt stmt "select 123.456789 from tdual"
+>   executeStmt stmt
+>   --buffer <- bindColBuffer stmt 1 sqlDTypeDouble 16
+>   more <- fetch stmt
+>   --s <- getFromBuffer buffer
+>   s <- getData stmt 1
+>   let expect :: Double; expect = 123.456789
+>   assertEqual "testFetchDouble" (Just expect) s
+>   more <- fetch stmt
+>   assertBool "testFetchDouble: EOD" (not more)
+>   freeStmt stmt
+
+> testFetchDatetime conn = do
+>   stmt <- allocStmt conn
+>   dbmsname <- liftM (map toLower) (getInfoDbmsName conn)
+>   flip finally (freeStmt stmt) ( do
+>     -- There is no common SQL standard for datetime literal text.
+>     -- Well, there is (timestamp), but MS SQL Server doesn't support it. Pah.
+>     -- And Oracle seems to also require a sane NLS setting e.g.
+>     --   alter session set NLS_TIMESTAMP_FORMAT = 'yyyy-mm-dd hh24:mi:ss'
+>     when (dbmsname == "oracle") ( do
+>         prepareStmt stmt "alter session set NLS_TIMESTAMP_FORMAT = 'yyyy-mm-dd hh24:mi:ss'"
+>         executeStmt stmt
+>       )
+>     --
+>     -- PostgreSQL doesn't appear to support the {fn ...} escape sequences;
+>     -- the text seems to be passed through unchanged (according to SQLNativeSql, anyway).
+>     -- THe MS SQL Server ODBC driver's SQLNativeSql also returns the text unchanged,
+>     -- but it doesn't seem to cause any grief on the server.
+>     --getNativeSql conn "select {fn CONVERT('1916-10-01 02:25:21', SQL_TIMESTAMP)}, {fn CONVERT('2005-10-01 00:00:00', SQL_TIMESTAMP)} from tdual" >>= putStrLn
+>     case dbmsname of
+>       "postgresql" -> 
+>         prepareStmt stmt "select cast ('1916-10-01 02:25:21' as timestamp), cast ('2005-10-01 00:00:00' as timestamp) from tdual"
+>       otherwise ->
+>         prepareStmt stmt "select {fn CONVERT('1916-10-01 02:25:21', SQL_TIMESTAMP)}, {fn CONVERT('2005-10-01 00:00:00', SQL_TIMESTAMP)} from tdual"
+>     executeStmt stmt
+>     let expect1 = mkUTCTime 1916 10  1  2 25 21
+>     let expect2 = mkUTCTime 2005 10  1  0  0  0
+>     buffer1 <- bindColBuffer stmt 1 0 (Just expect1)
+>     buffer2 <- bindColBuffer stmt 2 0 (Just expect2)
+>     more <- fetch stmt
+>     t1 <- getFromBuffer buffer1
+>     t2 <- getFromBuffer buffer2
+>     assertEqual "testFetchDatetime1" (Just expect1) t1
+>     assertEqual "testFetchDatetime2" (Just expect2) t2
+>     more <- fetch stmt
+>     assertBool "testFetchDatetime: EOD" (not more)
+>     )
+
+
+> testBindInt conn = do
+>   stmt <- allocStmt conn
+>   prepareStmt stmt "select ? from tdual"
+>   bindParamBuffer stmt 1 (Just (101::Int)) 0
+>   executeStmt stmt
+>   buffer <- bindColBuffer stmt 1 0 (Just (0::Int))
+>   more <- fetch stmt
+>   s <- getFromBuffer buffer
+>   let expect :: Int; expect = 101
+>   assertEqual "testFetchInt" (Just expect) s
+>   more <- fetch stmt
+>   assertBool "testFetchInt: EOD" (not more)
+>   freeStmt stmt
+
+> testBindString conn = do
+>   stmt <- allocStmt conn
+>   prepareStmt stmt "select ? from tdual"
+>   let expect = "abcdefghijklmnopqrstuvwxyz"
+>   bindParamBuffer stmt 1 (Just expect) 0
+>   executeStmt stmt
+>   buffer <- bindColBuffer stmt 1 1000 (Just expect)
+>   more <- fetch stmt
+>   s <- getUTF8StringFromBuffer buffer
+>   assertEqual "testBindString" (Just expect) s
+>   more <- fetch stmt
+>   assertBool "testBindString: EOD" (not more)
+>   -- test closeCursor can be called if we want to
+>   closeCursor stmt  -- not necessary when done just before freeStmt
+>   freeStmt stmt
+
+> testBindStringUTF8 conn = do
+>   stmt <- allocStmt conn
+>   prepareStmt stmt "select ? from tdual"
+>   let expect = "abc" ++ map chr [0x000080, 0x0007FF, 0x00FFFF, 0x10FFFF]
+>   bindParamBuffer stmt 1 (Just expect) 0
+>   executeStmt stmt
+>   buffer <- bindColBuffer stmt 1 1000 (Just expect)
+>   more <- fetch stmt
+>   s <- getUTF8StringFromBuffer buffer
+>   assertEqual "testBindStringUTF8 (PostgreSQL fails with Unicode driver, succeeds with ANSI)" (Just expect) s
+>   more <- fetch stmt
+>   assertBool "testBindStringUTF8: EOD" (not more)
+>   freeStmt stmt
+
+> testBindUTCTime conn = do
+>   stmt <- allocStmt conn
+>   flip finally (freeStmt stmt) ( do
+>     prepareStmt stmt "select ? from tdual"
+>     let expect :: UTCTime; expect = mkUTCTime 1971 10  1  2 25 21
+>     bindbuf <- bindParamBuffer stmt 1 (Just expect) 0
+>     executeStmt stmt
+>     buffer <- bindColBuffer stmt 1 undefined (Just expect)
+>     more <- fetch stmt
+>     t <- getUtcTimeFromBuffer buffer
+>     assertEqual "testBindUTCTime" (Just expect) t
+>     more <- fetch stmt
+>     assertBool "testBindUTCTime: EOD" (not more)
+>     )
+
+
+> testBindUTCTimeBoundary conn = do
+>   stmt <- allocStmt conn
+>   prepareStmt stmt "select ?, ? from tdual"
+>   -- 1753 seems to be about the earliest year MS SQL Server supports.
+>   let expect1 = mkUTCTime 1753 1 1 0 0 0
+>   let expect2 = mkUTCTime 9999 10  1  2 25 21
+>   let input1 = expect1
+>   let input2 = expect2
+>   inbuf1 <- bindParamBuffer stmt 1 (Just input1) 0
+>   inbuf2 <- bindParamBuffer stmt 2 (Just input2) 0
+>   executeStmt stmt
+>   buffer1 <- bindColBuffer stmt 1 100 (Just expect1)
+>   buffer2 <- bindColBuffer stmt 2 100 (Just expect2)
+>   more <- fetch stmt
+>   t1 <- getFromBuffer buffer1
+>   t2 <- getFromBuffer buffer2
+>   assertEqual "testBindUTCTimeBoundary1" (Just expect1) t1
+>   assertEqual "testBindUTCTimeBoundary2" (Just expect2) t2
+>   more <- fetch stmt
+>   assertBool "testBindUTCTimeBoundary: EOD" (not more)
+>   freeStmt stmt
+
+> testRebind conn = do
+>   stmt <- allocStmt conn
+>   prepareStmt stmt "select ? from tdual"
+>   --
+>   --closeCursor stmt  -- can't do this - function sequence error
+>   --
+>   let expect = "abc"
+>   bindParamBuffer stmt 1 (Just expect) 0
+>   executeStmt stmt
+>   buffer <- bindColBuffer stmt 1 100 (Just "")
+>   more <- fetch stmt
+>   s <- getUTF8StringFromBuffer buffer
+>   assertEqual "testRebind1" (Just expect) s
+>   more <- fetch stmt
+>   assertBool "testRebind1: EOD" (not more)
+>   --
+>   closeCursor stmt  -- reset stmt for rebinding, but do not dealloc
+>   --
+>   let expect = "xyz"
+>   bindParamBuffer stmt 1 (Just expect) 0
+>   executeStmt stmt
+>   buffer <- bindColBuffer stmt 1 100 (Just "")
+>   more <- fetch stmt
+>   s <- getUTF8StringFromBuffer buffer
+>   assertEqual "testRebind2" (Just expect) s
+>   more <- fetch stmt
+>   assertBool "testRebind2: EOD" (not more)
+>   --
+>   closeCursor stmt
+>   bindParamBuffer stmt 1 (Just expect) 0
+>   executeStmt stmt
+>   closeCursor stmt
+>   --
+>   freeStmt stmt
+
+
+> testUTF8 conn = do
+>   stmt <- allocStmt conn
+>   prepareStmt stmt "drop table t_utf8"
+>   ignoreError (executeStmt stmt)
+>   prepareStmt stmt "create table t_utf8(s varchar(50))"
+>   executeStmt stmt
+>   let expect = "abc" ++ map chr [0x000080, 0x0007FF, 0x00FFFF, 0x10FFFF]
+>   prepareStmt stmt ("insert into t_utf8 values ( '" ++ expect ++ "' )")
+>   executeStmt stmt
+>   prepareStmt stmt "select s from t_utf8"
+>   executeStmt stmt
+>   buffer <- bindColBuffer stmt 1 100 (Just expect)
+>   more <- fetch stmt
+>   s <- getUTF8StringFromBuffer buffer
+>   assertEqual "testUTF8" (Just expect) s
+>   freeStmt stmt
+
+> testDbmsName conn = do
+>   (liftM ("dbms-name: " ++) (getInfoDbmsName conn)) >>= putStrLn
+>   (liftM ("dbms-ver: " ++) (getInfoDbmsVer conn)) >>= putStrLn
+>   (liftM ("db-name: " ++) (getInfoDatabaseName conn)) >>= putStrLn
+>   (liftM ("driver-name: " ++) (getInfoDriverName conn)) >>= putStrLn
+>   (liftM ("driver-ver: " ++) (getInfoDriverVer conn)) >>= putStrLn
+
+
+> dropFixtureMultiResultSet = "DROP PROCEDURE takusenTestProc"
+> makeFixtureMultiResultSet = "CREATE PROCEDURE takusenTestProc"
+>   ++ " AS BEGIN"
+>   ++ " SELECT '1', '2' \n\n"
+>   ++ " SELECT '3', '4' \n\n"
+>   ++ " END;"
+
+> testMultiResultSet conn = do
+>   name <- liftM (map toLower) (getInfoDbmsName conn)
+>   when (name == "microsoft sql server") $ do
+>   stmt <- allocStmt conn
+>   printIgnoreError (prepareStmt stmt dropFixtureMultiResultSet)
+>   ignoreError (executeStmt stmt)
+>   printIgnoreError (prepareStmt stmt makeFixtureMultiResultSet)
+>   printIgnoreError (executeStmt stmt)
+>   prepareStmt stmt "{call takusenTestProc}"
+>   executeStmt stmt
+>   --
+>   buffer1 <- bindColBuffer stmt 1 100 (Just "")
+>   buffer2 <- bindColBuffer stmt 2 100 (Just "")
+>   more <- fetch stmt
+>   s1 <- getUTF8StringFromBuffer buffer1
+>   assertEqual "testMultiResultSet1" (Just "1") s1
+>   s2 <- getUTF8StringFromBuffer buffer2
+>   assertEqual "testMultiResultSet2" (Just "2") s2
+>   more <- fetch stmt
+>   assertBool "testMultiResultSet1: EOD" (not more)
+>   --
+>   more <- moreResults stmt
+>   assertBool "testMultiResultSet: more result-sets" more
+>   --
+>   buffer1 <- bindColBuffer stmt 1 100 (Just "")
+>   buffer2 <- bindColBuffer stmt 2 100 (Just "")
+>   more <- fetch stmt
+>   s1 <- getUTF8StringFromBuffer buffer1
+>   assertEqual "testMultiResultSet3" (Just "3") s1
+>   s2 <- getUTF8StringFromBuffer buffer2
+>   assertEqual "testMultiResultSet4" (Just "4") s2
+>   more <- fetch stmt
+>   assertBool "testMultiResultSet3: EOD" (not more)
+>   --
+>   more <- moreResults stmt
+>   assertBool "testMultiResultSet: no more result-sets" (not more)
+>   --
+>   prepareStmt stmt dropFixtureMultiResultSet
+>   executeStmt stmt
+>   freeStmt stmt
+
+
+> dropFixtureBindOutput = "DROP PROCEDURE takusenTestProc"
+> makeFixtureBindOutputSqlServer = "CREATE PROCEDURE takusenTestProc @x int output, @y varchar(200) output"
+>   ++ " AS BEGIN"
+>   ++ " declare @z varchar(200) \n\n"
+>   ++ " select @x = 2 * @x \n\n"
+>   ++ " select @z = 'output ' + @y + ' xxx' \n\n"
+>   ++ " select @y = @z \n\n"
+>   ++ " END;"
+
+> makeFixtureBindOutputOracle = "CREATE or replace PROCEDURE takusenTestProc(x in out number, y in out varchar)"
+>   ++ " AS BEGIN"
+>   ++ " x := x * 2;"
+>   ++ " y := 'output ' || y || ' xxx';"
+>   ++ " END;"
+
+> testBindOutput conn = do
+>   dbmsname <- liftM (map toLower) (getInfoDbmsName conn)
+>   case dbmsname of
+>     "microsoft sql server" -> k makeFixtureBindOutputSqlServer
+>     "oracle" -> k makeFixtureBindOutputOracle
+>     _ -> return ()
+>   where
+>   k makeFixture = do
+>   stmt <- allocStmt conn
+>   prepareStmt stmt dropFixtureBindOutput
+>   ignoreError (executeStmt stmt)
+>   prepareStmt stmt makeFixture
+>   executeStmt stmt
+>   --
+>   prepareStmt stmt "{call takusenTestProc(?,?)}"
+>   let input1 :: Int; input1 = 1234
+>   let input2 = "message"
+>   buffer1 <- bindParamBuffer stmt 1 (InOutParam (Just input1)) 0
+>   buffer2 <- bindParamBuffer stmt 2 (InOutParam (Just input2)) 200
+>   executeStmt stmt
+>   --
+>   i <- getFromBuffer buffer1
+>   assertEqual "testBindOutput" (Just (2*input1)) i
+>   s <- getUTF8StringFromBuffer buffer2
+>   assertEqual "testBindOutput" (Just "output message xxx") s
+>   --more <- fetch stmt  -- This will cause error:
+>   --
+>   --more <- moreResults stmt
+>   --assertBool "testBindOutput: more result-sets" (not more)
+>   --
+>   prepareStmt stmt dropFixtureMultiResultSet
+>   executeStmt stmt
+>   freeStmt stmt
+
+
+
+> printBufferContents buffer = do
+>   withForeignPtr (bindBufPtr buffer) $ \bptr -> do
+>   withForeignPtr (bindBufSzPtr buffer) $ \szptr -> do
+>   sz <- peek szptr
+>   printArrayContents (fromIntegral sz) (castPtr bptr)
+
+
+> testlist =
+>   testCreateStmt :
+>   testIsolationLevel :
+>   testFetchString :
+>   testFetchStringWithBuffer :
+>   testFetchInt :
+>   testFetchIntWithBuffer :
+>   testFetchDouble :
+>   testFetchDatetime :
+>   testBindInt :
+>   testBindString :
+>   testBindStringUTF8 :
+>   testBindUTCTime :
+>   testBindUTCTimeBoundary :
+>   testUTF8 :
+>   testRebind :
+>   --testDbmsName :
+>   testMultiResultSet :
+>   testBindOutput :
+>   []
+
+> testlist2 =
+>   testBindOutput :
+>   []
+
+> mkTestlist conn testlist = map (\testcase -> printIgnoreError (testcase conn)) testlist
+
+> parseArgs :: [String] -> IO String
+> parseArgs args = do
+>    let (dsn:_) = args
+>    return dsn
+
+> runTest :: [String] -> IO ()
+> runTest as = do
+>   connstr <- parseArgs as
+>   printPropagateError testCreateEnv
+>   printPropagateError testCreateConn
+>   printPropagateError (testConnect connstr)
+>   (env, conn) <- printPropagateError (createConn connstr)
+>   ignoreError (dropDual conn)
+>   printPropagateError (createDual conn)
+>   counts <- runTestTT "ODBC low-level tests" (mkTestlist conn testlist)
+>   printPropagateError (dropDual conn)
+>   closeConn (env, conn)
+>   return ()
Database/Oracle/Enumerator.lhs view
@@ -11,12 +11,11 @@ 
 
 > {-# OPTIONS -fglasgow-exts #-}
-> {-# OPTIONS -fallow-undecidable-instances #-}
-> {-# OPTIONS -fallow-overlapping-instances #-}
+> {-# LANGUAGE OverlappingInstances #-}
+> {-# LANGUAGE UndecidableInstances #-}
 
 > module Database.Oracle.Enumerator
 >   ( Session, connect
->   , prepareStmt, preparePrefetch
 >   , prepareQuery, prepareLargeQuery, prepareCommand, prepareLargeCommand
 >   , sql, sqlbind, prefetch, cmdbind
 >   , StmtHandle, Out(..)
@@ -35,7 +34,7 @@ > import Foreign
 > import Foreign.C
 > import Control.Monad
-> import Control.Exception
+> import Control.Exception.Extensible
 > import Control.Monad.Trans
 > import Control.Monad.Reader
 > import Data.Char (toLower)
@@ -47,8 +46,6 @@ > import System.Time
 > import System.IO (hPutStrLn, stderr)
 
-> {-# DEPRECATED prepareStmt "Use prepareQuery or prepareCommand instead" #-}
-> {-# DEPRECATED preparePrefetch "Use prepareLargeQuery instead" #-}
 
 --------------------------------------------------------------------
 -- ** Error handling
@@ -346,6 +343,10 @@ > closeStmt _ stmt = dispose stmt
 
 
+FIXME stmt should not be closed by these functions,
+because they don't create it.
+stmt should be closed in function that creates it.
+
 > setPrefetchCount :: Session -> StmtHandle -> Int -> IO ()
 > setPrefetchCount session stmt count = inSession session
 >   (\_ err _ -> with count $ \countPtr ->
@@ -353,7 +354,6 @@ >   ) (closeStmt session stmt)
 
 
-
 > stmtPrepare :: Session -> StmtHandle -> String -> IO ()
 > stmtPrepare session stmt sql = inSession session
 >   (\_ err _ -> OCI.stmtPrepare err stmt sql
@@ -440,11 +440,14 @@ 
 > doCommand sess str = do
 >   stmt <- getStmt sess
+>   -- stmtPrepare and execute both close the stmt if an exception is thrown,
+>   -- so there should be no need for bracket here.
 >   stmtPrepare sess stmt str
->   n <- execute sess stmt 1
+>   rc <- execute sess stmt 1
 >   closeStmt sess stmt
->   return (fromIntegral n)
+>   return rc
 
+
 > instance Command String Session where
 >   executeCommand sess str = executeCommand sess (sql str)
 
@@ -512,14 +515,6 @@ > beginsWithSelect text = isPrefixOf "select" . map toLower $ text
 > inferStmtType text = if beginsWithSelect text then SelectType else CommandType
 
-> prepareStmt :: QueryString -> PreparationA Session PreparedStmtObj
-> prepareStmt (QueryString sqltext) =
->   prepareStmt' (prefetchRowCount defaultResourceUsage) sqltext FreeManually (inferStmtType sqltext)
-
-> preparePrefetch :: Int -> QueryString -> PreparationA Session PreparedStmtObj
-> preparePrefetch count (QueryString sqltext) =
->   prepareStmt' count sqltext FreeManually (inferStmtType sqltext)
-
 > prepareQuery :: QueryString -> PreparationA Session PreparedStmtObj
 > prepareQuery (QueryString sqltext) =
 >   prepareStmt' (prefetchRowCount defaultResourceUsage) sqltext FreeManually SelectType
@@ -555,6 +550,7 @@ > newPreparedStmt lifetime iteration sess stmt = do
 >   c <- newIORef []
 >   b <- newIORef []
+
 >   return (PreparedStmtObj lifetime iteration stmt sess c b)
 
 --------------------------------------------------------------------
@@ -575,15 +571,11 @@ >     execute sess (stmtHandle stmt) iteration
 >     writeIORef (stmtCursors stmt) []
 >     action (BoundStmt stmt)
->   destroyStmt sess pstmt = do
->     -- FIXME  should also destroy all stmtCursors and stmtBuffers
->     closeStmt sess (stmtHandle pstmt)
+>   destroyStmt sess pstmt = closeStmt sess (stmtHandle pstmt)
 
 > instance DBBind (Maybe String) Session PreparedStmtObj BindObj where
 >   bindP = makeBindAction
 
-Disable this for now, as Strings have charset conversion issues for me...
-
 > instance DBBind (Out (Maybe String)) Session PreparedStmtObj BindObj where
 >   bindP (Out v) = makeOutputBindAction v
 
@@ -653,7 +645,7 @@ >   => Session -> PreparedStmtObj -> Maybe a -> Int -> IO ()
 > bindMaybe sess stmt v pos =
 >   bindWithValue v $ \ptrv -> do
->     bindByPos sess stmt pos (bindNullInd v) (castPtr ptrv) (bindSize v) (bindType v)
+>     bindByPos sess stmt pos (bindNullInd v) (castPtr ptrv) (bindDataSize v) (bindType v)
 
 Note currying... we don't provide the column-position;
 it's provided when bindRun is invoked.
@@ -670,9 +662,9 @@ >       withForeignPtr nullind $ \indptr -> do
 >       withForeignPtr sizeind $ \szeptr -> do
 >         poke (castPtr indptr) (bindNullInd v)
->         poke (castPtr szeptr) (bindSize v)
+>         poke (castPtr szeptr) (bindDataSize v)  -- input size
 >         bindWriteBuffer (castPtr bufptr) v
->       bindOutputByPos sess stmt pos (nullind, buffer, sizeind) (bindSize v) (bindType v)
+>       bindOutputByPos sess stmt pos (nullind, buffer, sizeind) (bindBufferSize v) (bindType v)
 >       let
 >         colbuf = ColumnBuffer
 >           { colBufBufferFPtr = buffer
@@ -700,10 +692,13 @@ > class OracleBind a where
 >   bindWithValue :: a -> (Ptr Word8 -> IO ()) -> IO ()
 >   bindWriteBuffer :: Ptr Word8 -> a -> IO ()
->   bindSize :: a -> Int
+>   bindDataSize :: a -> Int
 >   bindBufferSize :: a -> Int
->   bindBufferSize v = bindSize v
+>   bindBufferSize v = bindDataSize v
 >   bindNullInd :: a -> CShort
+>   -- non-Maybe types aren't nullable, so null-ind is always 0
+>   -- for values in these types.
+>   bindNullInd _ = 0
 >   bindType :: a -> CInt
 
 > instance OracleBind a => OracleBind (Maybe a) where
@@ -711,54 +706,53 @@ >   bindWithValue Nothing a = return ()
 >   bindWriteBuffer b (Just v) = bindWriteBuffer b v
 >   bindWriteBuffer b Nothing = return ()
->   bindSize (Just v) = bindSize v
->   bindSize Nothing = 0
+>   bindDataSize (Just v) = bindDataSize v
+>   bindDataSize Nothing = 0
+>   bindBufferSize (Just v) = bindBufferSize v
+>   bindBufferSize x@Nothing =
+>     let (Just v) = (Just undefined) `asTypeOf` x in bindBufferSize v
 >   bindNullInd (Just v) = 0
 >   bindNullInd Nothing = -1
 >   bindType (Just v) = bindType v
 >   bindType Nothing = bindType (undefined :: a)
 
 > instance OracleBind String where
+>   -- FIXME  should these be withUTF8String{Len} ?
 >   bindWithValue v a = withCString v (\p -> a (castPtr p))
->   bindWriteBuffer b s = withCStringLen s (\(p,l) -> copyBytes p (castPtr b) l)
->   bindSize s = fromIntegral (length s)
->   bindBufferSize s = 16000
->   bindNullInd _ = 0
+>   bindWriteBuffer b s = withCStringLen s (\(p,l) -> 
+>     copyBytes (castPtr b) p (1+l))
+>   bindDataSize s = fromIntegral (length s)
+>   bindBufferSize _ = 32000
 >   bindType _ = oci_SQLT_CHR
 
 > instance OracleBind Int where
 >   bindWithValue v a = withBinaryValue toCInt v (\p v -> poke (castPtr p) v) a
 >   bindWriteBuffer b v = poke (castPtr b) v
->   bindSize _ = (sizeOf (toCInt 0))
->   bindNullInd _ = 0
+>   bindDataSize _ = (sizeOf (toCInt 0))
 >   bindType _ = oci_SQLT_INT
 
 > instance OracleBind Double where
 >   bindWithValue v a = withBinaryValue toCDouble v (\p v -> poke (castPtr p) v) a
 >   bindWriteBuffer b v = poke (castPtr b) v
->   bindSize _ = (sizeOf (toCDouble 0.0))
->   bindNullInd _ = 0
+>   bindDataSize _ = (sizeOf (toCDouble 0.0))
 >   bindType _ = oci_SQLT_FLT
 
 > instance OracleBind CalendarTime where
 >   bindWithValue v a = withBinaryValue id v (\p dt -> calTimeToBuffer (castPtr p) dt) a
 >   bindWriteBuffer b v = calTimeToBuffer (castPtr b) v
->   bindSize _ = 7
->   bindNullInd _ = 0
+>   bindDataSize _ = 7
 >   bindType _ = oci_SQLT_DAT
 
 > instance OracleBind UTCTime where
 >   bindWithValue v a = withBinaryValue id v (\p dt -> utcTimeToBuffer (castPtr p) dt) a
 >   bindWriteBuffer b v = utcTimeToBuffer (castPtr b) v
->   bindSize _ = 7
->   bindNullInd _ = 0
+>   bindDataSize _ = 7
 >   bindType _ = oci_SQLT_DAT
 
 > instance OracleBind StmtHandle where
 >   bindWithValue v a = alloca (\p -> poke p v >> a (castPtr p))
 >   bindWriteBuffer b v = poke (castPtr b) v
->   bindSize _ = sizeOf nullPtr
->   bindNullInd _ = 0
+>   bindDataSize _ = sizeOf nullPtr
 >   bindType _ = oci_SQLT_RSET
 
 > withBinaryValue :: (OracleBind b) =>
@@ -768,7 +762,9 @@ >   -> (Ptr Word8 -> IO ())       -- ^ action to run over buffer; buffer will be freed on completion
 >   -> IO ()
 > withBinaryValue fn v pok action =
->   allocaBytes (bindSize v) $ \p -> do
+>   -- FIXME  is bindBufferSize better here?
+>   --allocaBytes (bindBufferSize v) $ \p -> do
+>   allocaBytes (bindDataSize v) $ \p -> do
 >   pok p (fn v)
 >   action (castPtr p)
 
@@ -868,7 +864,17 @@ >     execute sess (stmtHandle pstmt) 0
 >     return (Query pstmt sess (Just pstmt))
 
+> instance Statement CommandBind Session Query where
+>   makeQuery sess (CommandBind sqltext bas) = do
+>     let
+>      (PreparationA action) =
+>         prepareStmt' 1 sqltext FreeWithQuery CommandType
+>     pstmt <- action sess
+>     sequence_ (zipWith (\i (BindA ba) -> ba sess pstmt i) [1..] bas)
+>     execute sess (stmtHandle pstmt) 1
+>     return (Query pstmt sess (Just pstmt))
 
+
 > data ColumnBuffer = ColumnBuffer 
 >    { colBufBufferFPtr :: OCI.ColumnResultBuffer
 >    , colBufNullFPtr :: ForeignPtr CShort
@@ -885,24 +891,19 @@ >       _ -> return ()
 >   fetchOneRow query = do
 >     let pstmt = queryStmt query
->     case stmtType pstmt of
->       SelectType -> do
->         rc <- fetchRow (querySess query) (queryStmt query)
+>     -- Only call fetchRow if there are no bind output buffers
+>     -- If there are bind output buffers then assume this was a
+>     -- procedure call.
+>     -- In this case you will always get the same row over and over,
+>     -- so you'd better be careful with your iteratees
+>     buffers <- readIORef (stmtBuffers pstmt)
+>     if not (null buffers) then return True
+>       else do
+>         rc <- fetchRow (querySess query) pstmt
 >         return (rc /= oci_NO_DATA)
->       -- This is the CommandType case, where we have a command
->       -- (function/procedure call, or update-returning)
->       -- that will populate output bind buffers.
->       -- We don't need to do anything except return True to
->       -- indicate that data is available.
->       -- True also means the fetch will never terminate;
->       -- it will always give the same row over and over,
->       -- so you'd better be careful with your iteratees.
->       _ -> return True
 >   currentRowNum query =
 >     getRowCount (querySess query) (stmtHandle (queryStmt query))
->   freeBuffer q buffer = do
->     -- FIXME  we need to free StmtHandles
->     return ()
+>   freeBuffer q buffer = return ()
 
 
 This is where we differ the behaviour depending on the
Database/Oracle/OCIFunctions.lhs view
@@ -22,19 +22,20 @@ the OCI call, and some text identifying the wrapper function.
 See 'formatErrorCodeDesc' for the set of possible values for the OCI error numbers.
 
-> {-# OPTIONS -ffi #-}
-> {-# OPTIONS -fglasgow-exts #-}
+> {-# LANGUAGE ForeignFunctionInterface #-}
+> {-# LANGUAGE CPP #-}
 
 
 > module Database.Oracle.OCIFunctions where
 
 
+> import Prelude hiding (catch)
 > import Database.Oracle.OCIConstants
 > import Database.Util
 > import Foreign
 > import Foreign.C
 > import Control.Monad
-> import Control.Exception
+> import Control.Exception.Extensible
 > import Data.Dynamic
 > import System.Time
 > import Data.Time
@@ -98,11 +99,10 @@ 
 
 > catchOCI :: IO a -> (OCIException -> IO a) -> IO a
-> catchOCI = catchDyn
-
 > throwOCI :: OCIException -> a
-> throwOCI = throwDyn
-
+> instance Exception OCIException
+> catchOCI = catch
+> throwOCI = throw
 
 
 > mkCInt :: Int -> CInt
@@ -164,9 +164,20 @@ plsqlArrayMaxLen, plsqlCurrEltPtr, mode
 
 > foreign import ccall "oci.h OCIBindByPos" ociBindByPos ::
->   StmtHandle -> Ptr BindHandle -> ErrorHandle -> CUInt -> BufferPtr -> CInt
->   -> CUShort -> Ptr CShort -> Ptr CUShort -> Ptr CUShort
->   -> CUInt -> Ptr CUInt -> CUInt -> IO CInt
+>   StmtHandle
+>   -> Ptr BindHandle
+>   -> ErrorHandle
+>   -> CUInt  -- ^ position
+>   -> BufferPtr  -- ^ buffer containing data
+>   -> CInt  -- ^ max size of buffer
+>   -> CUShort  -- ^ SQL data type
+>   -> Ptr CShort  -- ^ null indicator ptr
+>   -> Ptr CUShort  -- ^ input + output size, or array of sizes
+>   -> Ptr CUShort  -- ^ array of return codes
+>   -> CUInt  -- ^ max array elements
+>   -> Ptr CUInt  -- ^ number of array elements
+>   -> CUInt  -- ^ mode
+>   -> IO CInt
 
 > foreign import ccall "oci.h OCIBindDynamic" ociBindDynamic ::
 >   BindHandle -> ErrorHandle -> ContextPtr -> FunPtr OCICallbackInBind
@@ -516,7 +527,7 @@ so we have this function to substitute ? with :n,
 where n starts at one and increases with each ?.
 
-We don't use this function into this library though;
+We don't use this function in this library though;
 it's used in the higher-level implementation of Enumerator.
 We prefer to retain flexibility at this lower-level,
 and not force arbitrary implementation choices too soon.
@@ -563,8 +574,8 @@ >   ErrorHandle
 >   -> StmtHandle
 >   -> Int   -- ^ Position
->   -> BindBuffer  -- ^ triple of (null-ind, payload, output-size)
->   -> Int   -- ^ payload input size in bytes
+>   -> BindBuffer  -- ^ triple of (null-ind, payload, input-size)
+>   -> Int   -- ^ buffer max size in bytes
 >   -> CInt  -- ^ SQL Datatype (from "Database.Oracle.OCIConstants")
 >   -> IO BindHandle
 > bindOutputByPos err stmt pos (nullIndFPtr, bufFPtr, sizeFPtr) sze sqltype =
@@ -669,6 +680,7 @@ >         withForeignPtr bufFPtr $ \bufferPtr ->
 >           withForeignPtr sizeFPtr $ \retSizePtr -> do
 >             retsize <- liftM cUShort2Int (peek retSizePtr)
+>             --putStrLn ("bufferToString: size = " ++ show retsize)
 >             pokeByteOff (castPtr bufferPtr) retsize nullByte
 >             val <- peekCString (castPtr bufferPtr)
 >             return (Just val)
+ Database/Oracle/Test/Enumerator.lhs view
@@ -0,0 +1,378 @@+
+|
+Module      :  Database.Oracle.Test.Enumerator
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+
+
+The Oracle multi-result-set tests require these database objects:
+
+CREATE OR REPLACE VIEW t_whole as
+select 0 as n  from dual union select 1 from dual
+union select 2 from dual union select 3 from dual
+union select 4 from dual union select 5 from dual
+union select 6 from dual union select 7 from dual
+union select 8 from dual union select 9 from dual
+;
+
+CREATE OR REPLACE VIEW t_natural as
+select n from
+( select t1.n + 10 * t10.n + 100 * t100.n as n
+from t_whole t1, t_whole t10, t_whole t100
+) t where n > 0 order by 1
+;
+
+create or replace package Takusen as type RefCursor is ref cursor; end;
+
+CREATE OR REPLACE PROCEDURE takusenTestProc
+(refc1 out Takusen.RefCursor, refc2 out Takusen.RefCursor) AS BEGIN
+OPEN refc1 FOR SELECT n*n from t_natural where n < 10 order by 1;
+OPEN refc2 FOR SELECT n, n*n, n*n*n from t_natural where n < 10 order by 1;
+END;
+
+select n, cursor(
+  SELECT nat2.n
+  , cursor(SELECT nat3.n from t_natural nat3 where nat3.n < nat2.n order by n)
+  from t_natural nat2 where nat2.n < nat.n order by n
+)
+from t_natural nat where n < 10 order by n;
+
+
+> {-# LANGUAGE OverlappingInstances #-}
+
+> module Database.Oracle.Test.Enumerator (runTest) where
+
+> import qualified Database.Oracle.Test.OCIFunctions as Low
+> import Database.Oracle.Enumerator
+> import Database.Util (print_)
+> import Database.Test.Performance as Perf
+> import Database.Test.Enumerator
+> import Control.Monad (when)
+> import Control.Monad.Trans (liftIO)
+> import Test.MiniUnit
+> import Data.Int
+> import System.Time
+
+
+> runTest :: Perf.ShouldRunTests -> [String] -> IO ()
+> runTest runPerf args = do
+>   let (user:pswd:dbname:_) = args
+>   Low.runTest args
+>   flip catchDB basicDBExceptionReporter $
+>     withSession (connect user pswd dbname) (testBody runPerf)
+
+> testBody runPerf = do
+>   runFixture OracleFunctions
+>   when (runPerf == Perf.RunTests) runPerformanceTests
+
+> runPerformanceTests = do
+>   makeFixture execDrop execDDL_
+>   beginTransaction RepeatableRead
+>   runTestTT "Oracle performance tests" (map (flip catchDB reportRethrow)
+>     [ timedSelect (prefetch 1000 sqlRows2Power20 []) 30 (2^20)
+>     , timedSelect (prefetch 1 sqlRows2Power17 []) 60 (2^17)
+>     , timedSelect (prefetch 1000 sqlRows2Power17 []) 6 (2^17)
+>     , timedCursor (prefetch 1 sqlRows2Power17 []) 60 (2^17)
+>     , timedCursor (prefetch 1000 sqlRows2Power17 []) 6 (2^17)
+>     ]
+>     )
+>   commit
+>   destroyFixture execDDL_
+
+
+> runFixture :: OracleFunctions -> DBM mark Session ()
+> runFixture fns = do
+>   makeFixture execDrop execDDL_
+>   execDDL_ makeFixtureMultiResultSet1
+>   execDDL_ makeFixtureMultiResultSet2
+>   execDDL_ makeFixtureMultiResultSet3
+>   execDDL_ makeFixtureMultiResultSet4
+>   execDDL_ makeFixtureBindOutput
+>   runTestTT "Oracle tests" (map (runOneTest fns) testList)
+>   execDDL_ dropFixtureBindOutput
+>   execDDL_ dropFixtureMultiResultSet4
+>   execDDL_ dropFixtureMultiResultSet3
+>   execDDL_ dropFixtureMultiResultSet2
+>   execDDL_ dropFixtureMultiResultSet1
+>   destroyFixture execDDL_
+
+> runOneTest fns t = catchDB (t fns) reportRethrow
+
+-----------------------------------------------------------
+
+> selectNoRows _ = selectTest sqlNoRows iterNoRows expectNoRows
+
+> selectTerminatesEarly _ = selectTest sqlTermEarly iterTermEarly expectTermEarly
+
+> selectFloatsAndInts fns = selectTest (sqlFloatsAndInts fns) iterFloatsAndInts expectFloatsAndInts
+
+> selectNullString _ = selectTest sqlNullString iterNullString expectNullString
+
+> selectEmptyString _ = selectTest sqlEmptyString iterEmptyString expectEmptyString
+
+> selectUnhandledNull _ = catchDB ( do
+>       selectTest sqlUnhandledNull iterUnhandledNull expectUnhandledNull
+>       assertFailure sqlUnhandledNull
+>   ) (\e -> return () )
+
+
+
+> selectNullDate dateFn = selectTest (sqlNullDate dateFn) iterNullDate expectNullDate
+
+> selectDate dateFn = selectTest (sqlDate dateFn) iterDate expectDate
+
+> selectCalDate dateFn = selectTest (sqlDate dateFn) iterCalDate expectCalDate
+
+> selectBoundaryDates dateFn = selectTest (sqlBoundaryDates dateFn) iterBoundaryDates expectBoundaryDates
+
+> selectCursor fns = actionCursor (sqlCursor fns)
+
+> selectExhaustCursor fns = actionExhaustCursor (sqlCursor fns)
+
+> selectBindString _ = actionBindString
+>     (prepareQuery (sql sqlBindString))
+>     [bindP "a2", bindP "b1"]
+
+
+> selectBindInt _ = actionBindInt
+>   (prepareQuery (sql sqlBindInt))
+>   [bindP (1::Int), bindP (2::Int)]
+
+
+> selectBindIntDoubleString _ = actionBindIntDoubleString
+>   (prefetch 0 sqlBindIntDoubleString [bindP (1::Int), bindP (2.2::Double), bindP "row 1", bindP (3::Int), bindP (4.4::Double), bindP "row 2"])
+
+> selectBindDate _ = actionBindDate
+>   (prefetch 1 sqlBindDate (map bindP expectBindDate))
+
+> selectBindBoundaryDates _ = actionBindBoundaryDates
+>   (prefetch 1 sqlBindBoundaryDates (map bindP expectBoundaryDates))
+
+> selectRebindStmt _ = actionRebind (prepareQuery (sql sqlRebind))
+>    [bindP (1::Int)] [bindP (2::Int)]
+
+> boundStmtDML _ = actionBoundStmtDML (prepareCommand (sql sqlBoundStmtDML))
+> boundStmtDML2 _ = withTransaction RepeatableRead $ do
+>   count <- execDML (cmdbind sqlBoundStmtDML [bindP (100::Int), bindP "100"])
+>   assertEqual sqlBoundStmtDML 1 count
+>   rollback
+
+
+> polymorphicFetchTest _ = actionPolymorphicFetch
+>   (prefetch 0 sqlPolymorphicFetch [bindP expectPolymorphicFetch])
+
+> polymorphicFetchTestNull _ = actionPolymorphicFetchNull
+>   (prefetch 1 sqlPolymorphicFetchNull [])
+
+> exceptionRollback _ = actionExceptionRollback sqlInsertTest4 sqlExceptionRollback
+
+
+FIXME  check definitions of whole and natural numbers
+
+> dropFixtureMultiResultSet1 = "DROP VIEW t_whole"
+> makeFixtureMultiResultSet1 = "CREATE OR REPLACE VIEW t_whole as"
+>   ++ " select 0 as n  from dual union select 1 from dual"
+>   ++ " union select 2 from dual union select 3 from dual"
+>   ++ " union select 4 from dual union select 5 from dual"
+>   ++ " union select 6 from dual union select 7 from dual"
+>   ++ " union select 8 from dual union select 9 from dual"
+
+> dropFixtureMultiResultSet2 = "DROP VIEW t_natural"
+> makeFixtureMultiResultSet2 = "CREATE OR REPLACE VIEW t_natural as"
+>   ++ " select n from"
+>   ++ " ( select t1.n + 10 * t10.n + 100 * t100.n as n"
+>   ++ "   from t_whole t1, t_whole t10, t_whole t100"
+>   ++ " ) t where n > 0 order by 1"
+
+
+> dropFixtureMultiResultSet3 = "DROP package Takusen"
+> makeFixtureMultiResultSet3 =
+>   "create or replace package Takusen as type RefCursor is ref cursor; end;"
+
+> dropFixtureMultiResultSet4 = "DROP PROCEDURE takusenTestProc"
+> makeFixtureMultiResultSet4 = "CREATE OR REPLACE PROCEDURE takusenTestProc"
+>   ++ " (refc1 out Takusen.RefCursor, refc2 out Takusen.RefCursor) AS BEGIN"
+>   ++ " OPEN refc1 FOR SELECT n*n from t_natural where n < 10 order by 1;"
+>   ++ " OPEN refc2 FOR SELECT n, n*n, n*n*n from t_natural where n < 10 order by 1;"
+>   ++ " END;"
+
+What would you need to do to make database functions and procedures
+callable from Haskell as if they were local functions (IO actions)?
+
+wrapPLSQLFunc funcname parms =
+  let
+     sqltext = "begin " ++ (head args) ++ " := " ++ funcname ++ "(" ++ placeholders ++ "); end;"
+     placeholders = concat (intersperse "," (tail args))
+     args = take (length parms) (map (\n -> ":x" ++ show n) [1..])
+  in cmdbind sqltext parms
+
+wrapPLSQLProc procname parms =
+  let
+     sqltext = "begin " ++ procname ++ "(" ++ placeholders ++ "); end;"
+     placeholders = concat (intersperse "," args)
+     args = take (length parms) (map (\n -> ":x" ++ show n) [1..])
+  in cmdbind sqltext parms
+
+convertCcy :: String -> Double -> String -> UTCTime -> DBM mark Session (String, Double)
+convertCcy ccyFrom valFrom ccyTo onDate = do
+  sqlcmd = wrapPLSQLFunc "pk_fx.convert_ccy"
+    [ bindP (Out (0 :: Double))
+    , bindP ccyFrom
+    , bindP valFrom
+    , bindP ccyTo
+    , bindP onDate
+    ]
+  let
+    iter :: Monad m => Double -> IterAct m Double
+    iter val seed = return (Left val)
+  result = doQuery sqlcmd iter undefined
+  return result
+
+> selectMultiResultSet _ = do
+>   let refcursor :: Maybe StmtHandle; refcursor = Just undefined
+>   withTransaction RepeatableRead $ do
+>   withPreparedStatement (prepareCommand (sql "begin takusenTestProc(:1,:2); end;")) $ \pstmt -> do
+>   withBoundStatement pstmt [bindP (Out refcursor), bindP (Out refcursor)] $ \bstmt -> do
+>     dummy <- doQuery bstmt iterMain ()
+>     result1 <- doQuery (NextResultSet pstmt) iterRS1 []
+>     assertEqual "selectMultiResultSet: RS1" [1,4,9,16,25,36,49,64,81] result1
+>     result2 <- doQuery (NextResultSet pstmt) iterRS2 []
+>     let expect = [(1,1,1),(2,4,8),(3,9,27),(4,16,64),(5,25,125),(6,36,216)
+>           ,(7,49,343),(8,64,512),(9,81,729)]
+>     assertEqual "selectMultiResultSet: RS2" expect result2
+>     return ()
+>   where
+>     iterMain :: (Monad m) => RefCursor StmtHandle -> RefCursor StmtHandle -> IterAct m ()
+>     iterMain c1 c2 acc = return (Left acc)
+>     iterRS1 :: (Monad m) => Int -> IterAct m [Int]
+>     iterRS1 i acc = result (acc ++ [i])
+>     iterRS2 :: (Monad m) => Int -> Int -> Int -> IterAct m [(Int, Int, Int)]
+>     iterRS2 i i2 i3 acc = result (acc ++ [(i, i2, i3)])
+
+
+> selectNestedMultiResultSet :: OracleFunctions -> DBM mark Session ()
+> selectNestedMultiResultSet _ = do
+>   let
+>     -- This returns two rows, each of which contains one cursor.
+>     -- The first cursor returns 101, the second 102.
+>     q = "select cursor(select n from dual) from"
+>       ++ " (select 101 as n from dual union select 102 from dual)"
+>     iterMain (c::RefCursor StmtHandle) acc = do
+>       rs <- doQuery c iterInner []
+>       result' (c:acc)
+>     iterInner (i::Int) acc = do
+>       if (i /= 101 && i /= 102)
+>         then assertFailure "selectNestedMultiResultSet: inner value not 101 or 102"
+>         else return ()
+>       result' (i:acc)
+>   withTransaction RepeatableRead $ do
+>   withPreparedStatement (prepareQuery (sql q)) $ \pstmt -> do
+>   withBoundStatement pstmt [] $ \bstmt -> do
+>       rs <- doQuery bstmt iterMain []
+>       return ()
+
+
+> selectNestedMultiResultSet2 :: OracleFunctions -> DBM mark Session ()
+> selectNestedMultiResultSet2 _ = do
+>   let
+>     q = "select n, cursor(SELECT nat2.n, cursor"
+>         ++ "     (SELECT nat3.n from t_natural nat3 where nat3.n < nat2.n order by n)"
+>         ++ "   from t_natural nat2 where nat2.n < nat.n order by n)"
+>         ++ " from t_natural nat where n < 10 order by n"
+>     iterMain   (outer::Int) (c::RefCursor StmtHandle) acc = do
+>       rs <- doQuery c (iterInner outer) []
+>       let expect = drop (9-outer) [8,7,6,5,4,3,2,1]
+>       assertEqual "processOuter" expect (map fst rs)
+>       result' ((outer,c):acc)
+>     iterInner outer (inner::Int) (c::RefCursor StmtHandle) acc = do
+>       rs <- doQuery c (iterInner2 outer inner) []
+>       let expect = drop (9-inner) [8,7,6,5,4,3,2,1]
+>       assertEqual "processInner" expect rs
+>       result' ((inner,c):acc)
+>     iterInner2 outer inner (i::Int) acc = do
+>       --print_ (show outer ++ " " ++ show inner ++ " " ++ show i)
+>       assertBool "processInner2" (i < inner)
+>       result' (i:acc)
+>   withTransaction RepeatableRead $ do
+>   withPreparedStatement (prepareQuery (sql q)) $ \pstmt -> do
+>   withBoundStatement pstmt [] $ \bstmt -> do
+>       rs <- doQuery bstmt iterMain []
+>       assertEqual "selectNestedMultiResultSet" [9,8,7,6,5,4,3,2,1] (map fst rs)
+>       --print_ ""
+
+> selectNestedMultiResultSet3 :: OracleFunctions -> DBM mark Session ()
+> selectNestedMultiResultSet3 _ = do
+>   let
+>     q = "select n, cursor(SELECT nat2.n, cursor"
+>         ++ "     (SELECT nat3.n from t_natural nat3 where nat3.n < nat2.n order by n)"
+>         ++ "   from t_natural nat2 where nat2.n < nat.n order by n)"
+>         ++ " from t_natural nat where n < 10 order by n"
+>     iterMain   (outer::Int) (c::RefCursor StmtHandle) acc = do
+>       rs <- doQuery c (iterInner outer) []
+>       let expect = drop (9-outer) [8,7,6,5,4,3,2,1]
+>       assertEqual "processOuter" expect (map fst rs)
+>       result' ((outer,c):acc)
+>     iterInner outer (inner::Int) (c::RefCursor StmtHandle) acc = do
+>       rs <- doQuery c (iterInner2 outer inner) []
+>       let expect = drop (9-inner) [8,7,6,5,4,3,2,1]
+>       assertEqual "processInner" expect rs
+>       result' ((inner,c):acc)
+>     iterInner2 outer inner (i::Int) acc = do
+>       --print_ (show outer ++ " " ++ show inner ++ " " ++ show i)
+>       assertBool "processInner2" (i < inner)
+>       result' (i:acc)
+>   withTransaction RepeatableRead $ do
+>       rs <- doQuery (sql q) iterMain []
+>       assertEqual "selectNestedMultiResultSet" [9,8,7,6,5,4,3,2,1] (map fst rs)
+>       --print_ ""
+
+> dropFixtureBindOutput = "DROP PROCEDURE takusenTestBindProc"
+
+> makeFixtureBindOutput = "CREATE or replace PROCEDURE takusenTestBindProc(x in out number, y in out varchar2)"
+>   ++ " AS BEGIN\n"
+>   ++ " y := 'output ' || y;\n"
+>   ++ " x := x * 2;\n"
+>   ++ " END;"
+
+> bindOutputString _ = do
+>   let sqltext = "begin takusenTestBindProc(:1,:2); end;"
+>   let qry = cmdbind sqltext [bindP (Out (1234::Int)), bindP (Out (Just "message"))]
+>   (x, s) <- doQuery qry iter undefined
+>   assertEqual "bindOutputString: int " 2468 x
+>   assertEqual "bindOutputString: string " "output message" s
+>   where
+>     iter :: (Monad m) => Int -> String -> IterAct m (Int, String)
+>     iter i s _ = return (Left (i, s))
+
+
+> bindOutput _ = do
+>   let sqltext =
+>         "begin :1 := :1 + 1;\n "
+>         ++ ":2 := :2 * 2;\n"
+>         ++ "end;"
+>   let qry = cmdbind sqltext [bindP (Out (44.4 :: Double)), bindP (Out (1234::Int))]
+>   (d, i) <- doQuery qry iter undefined
+>   assertEqual "bindOutput: double " 45.4 d
+>   assertEqual "bindOutput: int " 2468 i
+>   where
+>     iter :: (Monad m) => Double -> Int -> IterAct m (Double, Int)
+>     iter d i _ = return (Left (d, i))
+
+
+> testList :: [OracleFunctions -> DBM mark Session ()]
+> testList =
+>   [ selectNoRows, selectTerminatesEarly, selectFloatsAndInts
+>   , selectNullString, selectEmptyString, selectUnhandledNull
+>   , selectNullDate, selectDate, selectCalDate, selectBoundaryDates
+>   , selectCursor, selectExhaustCursor
+>   , selectBindString, selectBindInt, selectBindIntDoubleString
+>   , selectBindDate, selectBindBoundaryDates, selectRebindStmt
+>   , boundStmtDML, boundStmtDML2
+>   , polymorphicFetchTest, polymorphicFetchTestNull, exceptionRollback
+>   , selectMultiResultSet, selectNestedMultiResultSet
+>   , selectNestedMultiResultSet2, selectNestedMultiResultSet3
+>   , bindOutput, bindOutputString
+>   ]
+ Database/Oracle/Test/OCIFunctions.lhs view
@@ -0,0 +1,448 @@+
+|
+Module      :  Database.Oracle.Test.OCIFunctions
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+
+Test harness for "Database.Oracle.OCIFunctions".
+This module depends on on "Database.Oracle.OCIFunctions".
+so it should only use functions from there (and "Database.Oracle.OCIConstants").
+
+
+> module Database.Oracle.Test.OCIFunctions (runTest) where
+
+> import qualified Database.Oracle.OCIFunctions as OCI
+> import Database.Oracle.OCIFunctions (EnvHandle, ErrorHandle, ConnHandle, StmtHandle)
+> import Database.Oracle.OCIConstants
+> import Foreign.Ptr
+> import Foreign.C.String
+> import Foreign.C.Types
+> import Foreign
+> import System.IO
+> import System.Environment (getArgs)
+> import Control.Monad
+> import Test.MiniUnit
+> import Data.Char
+
+
+> nullAction :: IO ()
+> nullAction = return ()
+
+> printError :: String -> IO ()
+> printError s = hPutStrLn stderr s
+
+> reportAndIgnore :: ErrorHandle -> OCI.OCIException -> IO () -> IO ()
+> reportAndIgnore err ociexc cleanupAction = do
+>   (e, m) <- OCI.formatErrorMsg ociexc err
+>   printError $ (show e) ++ ": " ++ m
+>   cleanupAction
+
+> reportAndRethrow :: ErrorHandle -> OCI.OCIException -> IO () -> IO ()
+> reportAndRethrow err ociexc cleanupAction = do
+>   (_, m) <- OCI.formatErrorMsg ociexc err
+>   printError m
+>   cleanupAction
+>   OCI.throwOCI ociexc
+
+
+> logon :: (String, String, String) -> IO (EnvHandle, ErrorHandle, ConnHandle)
+> logon (testUser, testPswd, testDb) = do
+>   env <- OCI.envCreate
+>   err <- OCI.handleAlloc oci_HTYPE_ERROR (castPtr env)
+>   OCI.catchOCI ( do
+>     server <- OCI.handleAlloc oci_HTYPE_SERVER (castPtr env)
+>     OCI.serverAttach (castPtr err) (castPtr server) testDb
+>     conn <- OCI.handleAlloc oci_HTYPE_SVCCTX (castPtr env)
+>     -- the connection holds a reference to the server in one of its attributes
+>     OCI.setHandleAttr (castPtr err) (castPtr conn) oci_HTYPE_SVCCTX (castPtr server) oci_ATTR_SERVER
+>     session <- OCI.handleAlloc oci_HTYPE_SESSION (castPtr env)
+>     if (testUser == "")
+>       then do
+>         OCI.sessionBegin (castPtr err) (castPtr conn) (castPtr session) oci_CRED_EXT
+>       else do
+>         OCI.setHandleAttrString (castPtr err) (castPtr session) oci_HTYPE_SESSION testUser oci_ATTR_USERNAME
+>         OCI.setHandleAttrString (castPtr err) (castPtr session) oci_HTYPE_SESSION testPswd oci_ATTR_PASSWORD
+>         OCI.sessionBegin (castPtr err) (castPtr conn) (castPtr session) oci_CRED_RDBMS
+>     -- the connection also holds a reference to the session in one of its attributes
+>     OCI.setHandleAttr (castPtr err) (castPtr conn) oci_HTYPE_SVCCTX (castPtr session) oci_ATTR_SESSION
+>     -- and we need to create a valid transaction handle for the connection, too.
+>     trans <- OCI.handleAlloc oci_HTYPE_TRANS (castPtr env)
+>     OCI.setHandleAttr (castPtr err) (castPtr conn) oci_HTYPE_SVCCTX (castPtr trans) oci_ATTR_TRANS
+>     return (env, castPtr err, castPtr conn)
+>     ) (\ociexc -> do
+>       reportAndIgnore (castPtr err) ociexc nullAction
+>       return (nullPtr, nullPtr, nullPtr)
+>     )
+
+> logoff :: (EnvHandle, ErrorHandle, ConnHandle) -> IO ()
+> logoff (env, err, conn) = OCI.catchOCI ( do
+>     session <- OCI.getHandleAttr err (castPtr conn) oci_HTYPE_SVCCTX oci_ATTR_SESSION
+>     server <- OCI.getHandleAttr err (castPtr conn) oci_HTYPE_SVCCTX oci_ATTR_SERVER
+>     OCI.sessionEnd err conn session
+>     OCI.serverDetach err server
+>     OCI.handleFree oci_HTYPE_SESSION (castPtr session)
+>     OCI.handleFree oci_HTYPE_SERVER (castPtr server)
+>     OCI.handleFree oci_HTYPE_SVCCTX (castPtr conn)
+>     OCI.handleFree oci_HTYPE_ERROR (castPtr err)
+>     OCI.handleFree oci_HTYPE_ENV (castPtr env)
+>     OCI.terminate
+>   ) (\ociexc -> reportAndIgnore (castPtr err) ociexc nullAction)
+
+
+> testCreateEnv :: IO ()
+> testCreateEnv = do
+>   env <- OCI.envCreate
+>   OCI.handleFree oci_HTYPE_ENV (castPtr env)
+
+
+> testConnect :: (String, String, String) -> IO ()
+> testConnect args = do
+>   x <- logon args
+>   logoff x
+
+
+> getStmt :: EnvHandle -> ErrorHandle -> ConnHandle -> String -> IO StmtHandle
+> getStmt env err conn sql = do
+>   stmt <- OCI.handleAlloc oci_HTYPE_STMT (castPtr env)
+>   OCI.stmtPrepare err (castPtr stmt) sql
+>   OCI.stmtExecute err conn (castPtr stmt) 0
+>   return (castPtr stmt)
+
+
+> testBeginTrans :: (String, String, String) -> IO ()
+> testBeginTrans args = do
+>   (env, err, conn) <- logon args
+>   OCI.catchOCI ( do
+>       OCI.beginTrans err conn oci_TRANS_SERIALIZABLE 
+>       stmt <- getStmt env err conn "select dummy from dual"
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt)
+>     ) (\ociexc -> reportAndIgnore (castPtr err) ociexc nullAction)
+>   logoff (env, err, conn)
+
+
+> testExecute :: (String, String, String) -> IO ()
+> testExecute args = do
+>   (env, err, conn) <- logon args
+>   OCI.catchOCI ( do
+>       stmt <- getStmt env err conn "select dummy from dual"
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt)
+>     ) (\ociexc -> reportAndIgnore (castPtr err) ociexc nullAction)
+>   logoff (env, err, conn)
+
+
+> testFetch :: (String, String, String) -> IO ()
+> testFetch args = do
+>   (env, err, conn) <- logon args
+>   OCI.catchOCI ( do
+>       stmt <- getStmt env err conn "select dummy from dual"
+>       (_, buf, nullptr, sizeptr) <- OCI.defineByPos err (castPtr stmt) 1 100 oci_SQLT_CHR
+>       rc <- OCI.stmtFetch err (castPtr stmt)
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt)
+>     ) (\ociexc -> reportAndIgnore (castPtr err) ociexc nullAction)
+>   logoff (env, err, conn)
+
+> testFetchStmt :: (String, String, String) -> IO ()
+> testFetchStmt args = do
+>   (env, err, conn) <- logon args
+>   OCI.catchOCI ( do
+>       stmt <- getStmt env err conn "select cursor(select 101 from dual) from dual"
+>       (_, buf, nullptr, sizeptr) <- OCI.defineByPos err (castPtr stmt) 1 8 oci_SQLT_RSET
+>       stmt2 <- OCI.handleAlloc oci_HTYPE_STMT (castPtr env)
+>       withForeignPtr buf $ \p -> poke (castPtr p) stmt2
+>       rc <- OCI.stmtFetch err (castPtr stmt)
+>       -- stmt2 <- OCI.bufferToStmtHandle buf
+>       (_, buf, nullptr, sizeptr) <- OCI.defineByPos err (castPtr stmt2) 1 4 oci_SQLT_INT
+>       rc <- OCI.stmtFetch err (castPtr stmt2)
+>       mb_i <- OCI.bufferToInt nullptr buf
+>       assertEqual "testFetchStmt" (Just 101) mb_i
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt2)
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt)
+>     ) (\ociexc -> reportAndIgnore (castPtr err) ociexc nullAction)
+>   logoff (env, err, conn)
+
+
+> testNestedFetchStmt :: (String, String, String) -> IO ()
+> testNestedFetchStmt args = do
+>   let
+>     -- This returns two rows, each of which contains one cursor.
+>     -- The first cursor returns 101, the second 102.
+>     sql = "select cursor(select n from dual) from"
+>       ++ " (select 101 as n from dual union select 102 from dual)"
+>   (env, err, conn) <- logon args
+>   OCI.catchOCI ( do
+>       stmt <- getStmt env err conn sql
+>       -- Create result buffer bfor row 1 StmtHandle
+>       (_, obuf, nullptr, sizeptr) <- OCI.defineByPos err (castPtr stmt) 1 8 oci_SQLT_RSET
+>       stmt101 <- OCI.handleAlloc oci_HTYPE_STMT (castPtr env)
+>       withForeignPtr obuf $ \p -> poke (castPtr p) stmt101
+>       --
+>       -- Fetch row 1 of 2
+>       rc <- OCI.stmtFetch err (castPtr stmt)
+>       --
+>       -- Fetch stmt101 value
+>       (_, buf, nullptr, sizeptr) <- OCI.defineByPos err (castPtr stmt101) 1 4 oci_SQLT_INT
+>       rc <- OCI.stmtFetch err (castPtr stmt101)
+>       mb_101 <- OCI.bufferToInt nullptr buf
+>       assertEqual "testFetchStmt" (Just 101) mb_101
+>       --OCI.handleFree oci_HTYPE_STMT (castPtr stmt101)
+>       --
+>       -- Create result buffer for row 2 StmtHandle...
+>       -- or re-use the StmtHandle stmt101.
+>       -- Both ways work.
+>       --(_, obuf, nullptr, sizeptr) <- OCI.defineByPos err (castPtr stmt) 1 8 oci_SQLT_RSET
+>       --stmt102 <- OCI.handleAlloc oci_HTYPE_STMT (castPtr env)
+>       --withForeignPtr obuf $ \p -> poke (castPtr p) stmt102
+>       let stmt102 = stmt101
+>       --
+>       -- Fetch row 2 of 2
+>       rc <- OCI.stmtFetch err (castPtr stmt)
+>       -- What happens if we free here?
+>       -- Will the child cursor still be valid?
+>       -- No - we get ORA-01001: invalid cursor
+>       -- So it looks like closing the parent closes the children too.
+>       --OCI.handleFree oci_HTYPE_STMT (castPtr stmt)
+>       --
+>       -- Fetch stmt102 value
+>       (_, buf, nullptr, sizeptr) <- OCI.defineByPos err (castPtr stmt102) 1 4 oci_SQLT_INT
+>       rc <- OCI.stmtFetch err (castPtr stmt102)
+>       mb_102 <- OCI.bufferToInt nullptr buf
+>       assertEqual "testFetchStmt" (Just 102) mb_102
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt102)
+>       --
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt)
+>     ) (\ociexc -> reportAndIgnore (castPtr err) ociexc nullAction)
+>   logoff (env, err, conn)
+
+
+
+> testFetchFail :: (String, String, String) -> IO ()
+> testFetchFail args = do
+>   (env, err, conn) <- logon args
+>   OCI.catchOCI ( do
+>       stmt <- getStmt env err conn "select dummy, 1 from dual"
+>       (_, buf, nullptr, sizeptr) <- OCI.defineByPos err (castPtr stmt) 1 100 oci_SQLT_CHR
+>       rc <- OCI.stmtFetch err (castPtr stmt)
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt)
+>     ) (\ociexc -> reportAndIgnore (castPtr err) ociexc nullAction)
+>   logoff (env, err, conn)
+
+
+> testBind :: (String, String, String) -> IO ()
+> testBind args = do
+>   (env, err, conn) <- logon args
+>   OCI.catchOCI ( do
+>       stmt <- OCI.handleAlloc oci_HTYPE_STMT (castPtr env)
+>       -- Oracle can't cope with ? as a bind variable placeholder.
+>       -- We must use the :x style instead.
+>       -- Sqlite can cope with either. I think the ANSI/ISO standard is :n.
+>       OCI.stmtPrepare err (castPtr stmt)
+>         (OCI.substituteBindPlaceHolders "select :1 from dual union select :2 from dual")
+>       withCStringLen "hello" $ \(cstr, clen) ->
+>         OCI.bindByPos err (castPtr stmt) 1 0 (castPtr cstr) clen oci_SQLT_CHR
+>       withCStringLen "hello2" $ \(cstr, clen) ->
+>         OCI.bindByPos err (castPtr stmt) 2 0 (castPtr cstr) clen oci_SQLT_CHR
+>       OCI.stmtExecute err conn (castPtr stmt) 0
+>       buffer@(_, buf, nullptr, sizeptr) <- OCI.defineByPos err (castPtr stmt) 1 100 oci_SQLT_CHR
+>       rc <- OCI.stmtFetch err (castPtr stmt)
+>       s <- OCI.bufferToString buffer
+>       rc <- OCI.stmtFetch err (castPtr stmt)
+>       s <- OCI.bufferToString buffer
+>       rc <- OCI.stmtFetch err (castPtr stmt)
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt)
+>     ) (\ociexc -> reportAndIgnore (castPtr err) ociexc nullAction)
+>   logoff (env, err, conn)
+
+> testOutputBind :: (String, String, String) -> IO ()
+> testOutputBind args = do
+>   (env, err, conn) <- logon args
+>   OCI.catchOCI ( do
+>       stmt <- OCI.handleAlloc oci_HTYPE_STMT (castPtr env)
+>       -- Oracle can't cope with ? as a bind variable placeholder.
+>       -- We must use the :x style instead.
+>       -- Sqlite can cope with either. I think the ANSI/ISO standard is :n.
+>       OCI.stmtPrepare err (castPtr stmt) (OCI.substituteBindPlaceHolders
+>         ("begin if :1 <> 'hello' then "
+>         ++ "raise_application_error(-20001, 'xx-' || :1 || '-xx'); end if; "
+>         ++ ":1 := 'abcdefg' || substr(:1, 1, 1) || 'ijk'; :2 := 1026; end;"))
+>       nullIndFPtr1 <- mallocForeignPtr
+>       nullIndFPtr2 <- mallocForeignPtr
+>       sizeFPtr1 <- mallocForeignPtr
+>       sizeFPtr2 <- mallocForeignPtr
+>       cintFPtr <- mallocForeignPtrBytes (sizeOf (0::CInt))
+>       cstrFPtr <- mallocForeignPtrBytes 16000  -- size of "hello"
+>       withForeignPtr cstrFPtr $ \p ->
+>         withCStringLen "hello" $ \(cstr, clen) -> copyBytes p (castPtr cstr) (clen+1)
+>       withForeignPtr sizeFPtr1 $ \p -> poke p 5
+>       withForeignPtr sizeFPtr2 $ \p -> poke p (fromIntegral (sizeOf (0::CInt)))
+>       OCI.bindOutputByPos err (castPtr stmt) 1 (nullIndFPtr1, castForeignPtr cstrFPtr, sizeFPtr1) 16000 oci_SQLT_CHR
+>       OCI.bindOutputByPos err (castPtr stmt) 2 (nullIndFPtr2, castForeignPtr cintFPtr, sizeFPtr2) (sizeOf (0::CInt)) oci_SQLT_INT
+>       OCI.stmtExecute err conn (castPtr stmt) 1
+>       s <- withForeignPtr cstrFPtr (peekCString . castPtr)
+>       assertEqual "testOutputBind: 1" "abcdefghijk" s
+>       ind <- withForeignPtr nullIndFPtr1 peek
+>       assertEqual "testOutputBind: 2" 0 ind
+>       i <- withForeignPtr cintFPtr peek
+>       assertEqual "testOutputBind: 3" 1026 (i :: CInt)
+>       size <- withForeignPtr sizeFPtr1 peek >>= return . fromIntegral
+>       assertEqual "testOutputBind: 4" 11 size
+>       size <- withForeignPtr sizeFPtr2 peek >>= return . fromIntegral
+>       assertEqual "testOutputBind: 5" (sizeOf (0::CInt)) size
+>       s <- OCI.bufferToString (undefined, castForeignPtr cstrFPtr, nullIndFPtr1, sizeFPtr1)
+>       assertEqual "testOutputBind: 6" (Just "abcdefghijk") s
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt)
+>     ) (\ociexc -> reportAndIgnore (castPtr err) ociexc nullAction)
+>   logoff (env, err, conn)
+
+> testOutputBindNoStrings :: (String, String, String) -> IO ()
+> testOutputBindNoStrings args = do
+>   (env, err, conn) <- logon args
+>   OCI.catchOCI ( do
+>       stmt <- OCI.handleAlloc oci_HTYPE_STMT (castPtr env)
+>       OCI.stmtPrepare err (castPtr stmt) (OCI.substituteBindPlaceHolders
+>         ("begin if :1 <> 2 then "
+>         ++ "raise_application_error(-20001, 'xx-' || to_char(:1) || '-xx'); end if; "
+>         ++ ":1 := 130; :2 := 1026; end;"))
+>       let sizeOfCInt = sizeOf (0::CInt)
+>       nullIndFPtr1 <- mallocForeignPtr
+>       nullIndFPtr2 <- mallocForeignPtr
+>       sizeFPtr1 <- mallocForeignPtr
+>       sizeFPtr2 <- mallocForeignPtr
+>       cintFPtr1 <- mallocForeignPtrBytes sizeOfCInt
+>       cintFPtr2 <- mallocForeignPtrBytes sizeOfCInt
+>       withForeignPtr cintFPtr1 $ \p -> poke p 2
+>       withForeignPtr cintFPtr2 $ \p -> poke p 3
+>       withForeignPtr sizeFPtr1 $ \p -> poke p (fromIntegral sizeOfCInt)
+>       withForeignPtr sizeFPtr2 $ \p -> poke p (fromIntegral sizeOfCInt)
+>       let buffer1 = (nullIndFPtr1, castForeignPtr cintFPtr1, sizeFPtr1)
+>       let buffer2 = (nullIndFPtr2, castForeignPtr cintFPtr2, sizeFPtr2)
+>       OCI.bindOutputByPos err (castPtr stmt) 1 buffer1 sizeOfCInt oci_SQLT_INT
+>       OCI.bindOutputByPos err (castPtr stmt) 2 buffer2 sizeOfCInt oci_SQLT_INT
+>       OCI.stmtExecute err conn (castPtr stmt) 1
+>       ind <- withForeignPtr nullIndFPtr1 peek
+>       assertEqual "testOutputBind: 0" 0 ind
+>       i <- withForeignPtr cintFPtr1 peek
+>       assertEqual "testOutputBind: 1" 130 (i :: CInt)
+>       ind <- withForeignPtr nullIndFPtr2 peek
+>       assertEqual "testOutputBind: 2" 0 ind
+>       i <- withForeignPtr cintFPtr2 peek
+>       assertEqual "testOutputBind: 3" 1026 (i :: CInt)
+>       size <- withForeignPtr sizeFPtr1 peek >>= return . fromIntegral
+>       assertEqual "testOutputBind: 4" sizeOfCInt size
+>       size <- withForeignPtr sizeFPtr2 peek >>= return . fromIntegral
+>       assertEqual "testOutputBind: 5" sizeOfCInt size
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt)
+>     ) (\ociexc -> reportAndIgnore (castPtr err) ociexc nullAction)
+>   logoff (env, err, conn)
+
+> testOutputStmtBind :: (String, String, String) -> IO ()
+> testOutputStmtBind args = do
+>   (env, err, conn) <- logon args
+>   OCI.catchOCI ( do
+>       stmt <- OCI.handleAlloc oci_HTYPE_STMT (castPtr env)
+>       OCI.stmtPrepare err (castPtr stmt) (OCI.substituteBindPlaceHolders
+>         ("begin open :1 for select dummy from dual; end;"))
+>       nullIndFPtr <- mallocForeignPtr
+>       sizeFPtr <- mallocForeignPtr
+>       bufrFPtr <- mallocForeignPtrBytes (sizeOf nullPtr)
+>       -- you have to pass in a valid Statement Handle
+>       -- is it replaced or just modified?
+>       stmtx <- OCI.handleAlloc oci_HTYPE_STMT (castPtr env)
+>       withForeignPtr bufrFPtr $ \p -> poke p (castPtr stmtx)
+>       withForeignPtr sizeFPtr $ \p -> poke p (fromIntegral (sizeOf nullPtr))
+>       OCI.bindOutputByPos err (castPtr stmt) 1 (nullIndFPtr, castForeignPtr bufrFPtr, sizeFPtr) (sizeOf nullPtr) oci_SQLT_RSET
+>       OCI.stmtExecute err conn (castPtr stmt) 1
+>       ind <- withForeignPtr nullIndFPtr $ \p -> peek p
+>       assertEqual "testOutputStmtBind: ind" 0 ind
+>       --stmt2 <- withForeignPtr bufrFPtr (peek . castPtr)
+>       let stmt2 = stmtx
+>       buffer@(_, buf, nullptr, sizeptr) <- OCI.defineByPos err (castPtr stmt2) 1 100 oci_SQLT_CHR
+>       rc <- OCI.stmtFetch err (castPtr stmt2)
+>       s <- OCI.bufferToString buffer
+>       assertEqual "testOutputStmtBind: stmt2 dummy" (Just "X") s
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt2)
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt)
+>     ) (\ociexc -> reportAndIgnore (castPtr err) ociexc nullAction)
+>   logoff (env, err, conn)
+
+
+This just shows that the parent StmtHandle can be safely
+closed before we fetch from the child, and this doesn't
+seem to matter.
+This only works for PL/SQL statements that have output bind variables.
+For select statements that return cursors, closing the parent
+statement closes all the child cursors too.
+
+> testOutputStmtBindCloseEarly :: (String, String, String) -> IO ()
+> testOutputStmtBindCloseEarly args = do
+>   (env, err, conn) <- logon args
+>   OCI.catchOCI ( do
+>       stmt <- OCI.handleAlloc oci_HTYPE_STMT (castPtr env)
+>       OCI.stmtPrepare err (castPtr stmt) (OCI.substituteBindPlaceHolders
+>         ("begin open :1 for select 'A' from dual; end;"))
+>       nullIndFPtr <- mallocForeignPtr
+>       sizeFPtr <- mallocForeignPtr
+>       bufrFPtr <- mallocForeignPtrBytes (sizeOf nullPtr)
+>       -- you have to pass in a valid Statement Handle
+>       -- is it replaced or just modified?
+>       stmtx <- OCI.handleAlloc oci_HTYPE_STMT (castPtr env)
+>       withForeignPtr bufrFPtr $ \p -> poke p (castPtr stmtx)
+>       withForeignPtr sizeFPtr $ \p -> poke p (fromIntegral (sizeOf nullPtr))
+>       OCI.bindOutputByPos err (castPtr stmt) 1 (nullIndFPtr, castForeignPtr bufrFPtr, sizeFPtr) (sizeOf nullPtr) oci_SQLT_RSET
+>       OCI.stmtExecute err conn (castPtr stmt) 1
+>       ind <- withForeignPtr nullIndFPtr $ \p -> peek p
+>       assertEqual "testOutputStmtBindCloseEarly: ind" 0 ind
+>       --stmt2 <- withForeignPtr bufrFPtr (peek . castPtr)
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt)
+>       let stmt2 = stmtx
+>       buffer@(_, buf, nullptr, sizeptr) <- OCI.defineByPos err (castPtr stmt2) 1 100 oci_SQLT_CHR
+>       rc <- OCI.stmtFetch err (castPtr stmt2)
+>       s <- OCI.bufferToString buffer
+>       assertEqual "testOutputStmtBindCloseEarly: stmt2 dummy" (Just "A") s
+>       OCI.handleFree oci_HTYPE_STMT (castPtr stmt2)
+>     ) (\ociexc -> reportAndIgnore (castPtr err) ociexc nullAction)
+>   logoff (env, err, conn)
+
+> testSubst input expect = do
+>   let actual = OCI.substituteBindPlaceHolders input
+>   when (actual /= expect) (error $ "testSubstBindPlaceHolders failed: " ++ input ++ " -> " ++ actual)
+
+> testSubstituteBindPlaceHolders :: IO ()
+> testSubstituteBindPlaceHolders = do
+>    testSubst "?'?'?" ":1'?':2"
+>    testSubst "?" ":1"
+>    testSubst "" ""
+>    testSubst "x" "x"
+>    testSubst "????????????" ":1:2:3:4:5:6:7:8:9:10:11:12"
+>    testSubst "?'''?'''''?"   ":1'''?''''':2"
+
+
+> parseArgs :: [String] -> IO (String, String, String)
+> parseArgs args = do
+>    let [u, p, d] = args
+>    return (u, p, d)
+
+> testlist args =
+>     [ testCreateEnv
+>     , testConnect args
+>     , testBeginTrans args
+>     , testExecute args
+>     , testFetch args
+>     , testFetchFail args
+>     , testFetchStmt args
+>     , testNestedFetchStmt args
+>     , testBind args
+>     , testOutputBind args
+>     , testOutputBindNoStrings args
+>     , testOutputStmtBind args
+>     , testOutputStmtBindCloseEarly args
+>     , testSubstituteBindPlaceHolders
+>     ]
+
+> runTest :: [String] -> IO ()
+> runTest as = do
+>   args <- parseArgs as
+>   counts <- runTestTT "Oracle low-level tests" (testlist args)
+>   return ()
Database/PostgreSQL/Enumerator.lhs view
@@ -11,8 +11,8 @@ 
 
 > {-# OPTIONS -fglasgow-exts #-}
-> {-# OPTIONS -fallow-undecidable-instances #-}
-> {-# OPTIONS -fallow-overlapping-instances #-}
+> {-# LANGUAGE OverlappingInstances #-}
+> {-# LANGUAGE UndecidableInstances #-}
 
 > module Database.PostgreSQL.Enumerator
 >   ( Session, connect, ConnectAttr(..)
@@ -29,7 +29,6 @@ > import Database.InternalEnumerator
 > import Foreign.C
 > import Control.Monad
-> import Control.Exception (catchDyn, throwDyn, throwIO)
 > import qualified Database.PostgreSQL.PGFunctions as DBAPI
 > import Data.Char
 > import Data.Dynamic
Database/PostgreSQL/PGFunctions.lhs view
@@ -10,14 +10,17 @@ Simple wrappers for PostgreSQL functions (FFI) plus middle-level
 wrappers (in the second part of this file)
 
-> {-# OPTIONS -ffi #-}
+
 > {-# OPTIONS -fglasgow-exts #-}
+> {-# LANGUAGE ForeignFunctionInterface #-}
+> {-# LANGUAGE CPP #-}
 
 > module Database.PostgreSQL.PGFunctions where
 
+> import Prelude hiding (catch)
 > import Database.Util
 > import Control.Monad
-> import Control.Exception
+> import Control.Exception.Extensible
 > import Data.Dynamic
 > import Data.Int
 > import Data.Time
@@ -47,13 +50,12 @@ >   show (PGException i s) = "PGException " ++ (show i) ++ " " ++ s
 
 > catchPG :: IO a -> (PGException -> IO a) -> IO a
-> catchPG = catchDyn
-
-> throwPG :: Integral a => a -> String -> any
-> throwPG rc s = throwDyn (PGException (fromIntegral rc) s)
-
-> rethrowPG :: PGException -> any
-> rethrowPG = throwDyn
+> throwPG :: Integral i => i -> String -> a
+> rethrowPG :: PGException -> a
+> instance Exception PGException
+> catchPG = catch
+> throwPG rc s = throw (PGException (fromIntegral rc) s)
+> rethrowPG = throw
 
 > cStr :: CStringLen -> CString
 > cStr = fst
+ Database/PostgreSQL/Test/Enumerator.lhs view
@@ -0,0 +1,352 @@+
+|
+Module      :  Database.PostgreSQL.Test.Enumerator
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+
+
+
+Can we support database functions that return/create multiple result-sets?
+Oracle, MS Sql Server, and Sybase have them,
+and we can simulate them in Postgres with the code below.
+
+CREATE TRUSTED PROCEDURAL LANGUAGE 'plpgsql' HANDLER plpgsql_call_handler;
+
+CREATE OR REPLACE VIEW t_whole as
+select 0 as n
+union select 1
+union select 2
+union select 3
+union select 4
+union select 5
+union select 6
+union select 7
+union select 8
+union select 9
+;
+
+CREATE OR REPLACE VIEW t_natural as
+select n from
+( select t1.n + 10 * t10.n + 100 * t100.n as n
+  from t_whole t1, t_whole t10, t_whole t100
+) t
+where n > 0
+order by 1
+;
+
+DROP FUNCTION takusenTestFunc() ;
+
+CREATE OR REPLACE FUNCTION takusenTestFunc() RETURNS SETOF refcursor AS \$\$
+DECLARE refc1 refcursor; refc2 refcursor;
+BEGIN
+    OPEN refc1 FOR SELECT n*n from t_natural where n < 10 order by 1;
+    RETURN NEXT refc1;
+    OPEN refc2 FOR SELECT n, n*n, n*n*n from t_natural where n < 10 order by 1;
+    RETURN NEXT refc2;
+END;\$\$ LANGUAGE plpgsql;
+
+
+-- this select returns two values (rows), both strings (well, refcursors),
+-- which are the cursor names.
+select * from myfunc();
+
+fetch all from "<unnamed portal 1>";
+fetch all from "<unnamed portal 2>";
+commit;
+
+
+Another example:
+
+CREATE OR REPLACE FUNCTION takusenTestFunc(lim int4) RETURNS refcursor AS \$\$
+DECLARE
+    refc refcursor;
+BEGIN
+    OPEN refc FOR SELECT n, takusenTestFunc2(n) from t_natural where n < lim order by n;
+    RETURN refc;
+END;
+\$\$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION takusenTestFunc2(lim int4) RETURNS refcursor AS \$\$
+DECLARE
+    refc refcursor;
+BEGIN
+    OPEN refc FOR SELECT n from t_natural where n < lim order by n;
+    RETURN refc;
+END;
+\$\$ LANGUAGE plpgsql;
+
+SELECT n, takusenTestFunc(n) from t_natural where n < 10 order by n;
+
+
+> {-# LANGUAGE OverlappingInstances #-}
+
+> module Database.PostgreSQL.Test.Enumerator (runTest) where
+
+> import qualified Database.PostgreSQL.Test.PGFunctions as Low
+> import Database.PostgreSQL.Enumerator
+> import Database.Test.Performance as Perf
+> import Database.Test.Enumerator
+> import Control.Monad (when)
+> import Test.MiniUnit
+> import Data.Int
+> import Data.List
+> import System.Time
+
+
+> runTest :: Perf.ShouldRunTests -> [String] -> IO ()
+> runTest runPerf args = do
+>   putStrLn "PostgreSQL tests"
+>   let (user:pswd:dbname:_) = args
+>   Low.runTest user
+>   flip catchDB basicDBExceptionReporter $ do
+>     (r, conn1) <- withContinuedSession (connect [CAuser user]) (testBody runPerf)
+>     withSession conn1 testPartTwo
+
+> testBody runPerf = do
+>   runFixture PGSqlFunctions
+>   when (runPerf == Perf.RunTests) runPerformanceTests
+
+> testPartTwo = do
+>   makeFixture execDrop execDDL_
+>   destroyFixture execDDL_
+
+> runPerformanceTests = do
+>   makeFixture execDrop execDDL_
+>   beginTransaction RepeatableRead
+>   runTestTT "PostgreSQL performance tests" (map (flip catchDB reportRethrow)
+>     [ timedSelect (prefetch 1000 sqlRows2Power20 []) 40 (2^20)
+>     , timedSelect (prefetch 1 sqlRows2Power17 []) 40 (2^17)
+>     , timedSelect (prefetch 1000 sqlRows2Power17 []) 5 (2^17)
+>     , timedCursor (prefetch 1 sqlRows2Power17 []) 40 (2^17)
+>     , timedCursor (prefetch 1000 sqlRows2Power17 []) 5 (2^17)
+>     ]
+>     )
+>   commit
+>   destroyFixture execDDL_
+
+
+> runFixture :: PGSqlFunctions -> DBM mark Session ()
+> runFixture fns = do
+>   makeFixture execDrop execDDL_
+>   execDDL_ makeFixtureNestedMultiResultSet1
+>   execDDL_ makeFixtureNestedMultiResultSet2
+>   execDDL_ makeFixtureNestedMultiResultSet3
+>   execDDL_ makeFixtureNestedMultiResultSet4
+>   execDDL_ makeFixtureMultiResultSet1
+>   runTestTT "Postgres tests" (map (runOneTest fns) testList)
+>   execDDL_ dropFixtureMultiResultSet1
+>   execDDL_ dropFixtureNestedMultiResultSet4
+>   execDDL_ dropFixtureNestedMultiResultSet3
+>   execDDL_ dropFixtureNestedMultiResultSet2
+>   execDDL_ dropFixtureNestedMultiResultSet1
+>   destroyFixture execDDL_
+
+> runOneTest fns t = catchDB (t fns) reportRethrow
+
+-----------------------------------------------------------
+
+> selectNoRows _ = selectTest sqlNoRows iterNoRows expectNoRows
+
+> selectTerminatesEarly _ = selectTest sqlTermEarly iterTermEarly expectTermEarly
+
+> selectFloatsAndInts fns = selectTest (sqlFloatsAndInts fns) iterFloatsAndInts expectFloatsAndInts
+
+> selectNullString _ = selectTest sqlNullString iterNullString expectNullString
+
+> selectEmptyString _ = selectTest sqlEmptyString iterEmptyString expectEmptyString
+
+> selectUnhandledNull _ = catchDB ( do
+>       selectTest sqlUnhandledNull iterUnhandledNull expectUnhandledNull
+>       assertFailure sqlUnhandledNull
+>   ) (\e -> return () )
+
+
+
+> selectNullDate dateFn = selectTest (sqlNullDate dateFn) iterNullDate expectNullDate
+
+> selectDate dateFn = selectTest (sqlDate dateFn) iterDate expectDate
+
+> selectCalDate dateFn = selectTest (sqlDate dateFn) iterCalDate expectCalDate
+
+> selectBoundaryDates dateFn = selectTest (sqlBoundaryDates dateFn) iterBoundaryDates expectBoundaryDates
+
+> selectCursor fns = actionCursor (sqlCursor fns)
+
+> selectExhaustCursor fns = actionExhaustCursor (sqlCursor fns)
+
+Note that these two tests use the same prepared statement name.
+This tests that the statement is properly deallocated, through use of
+withPreparedStatement.
+
+> selectBindString _ = actionBindString
+>   (prepareQuery "1" (sql sqlBindString) [bindType "", bindType ""])
+>   [bindP "a2", bindP "b1"]
+
+> selectBindInt _ = actionBindInt
+>   (prepareQuery "1" (sql sqlBindInt) (map bindType expectBindInt))
+>   [bindP (1::Int), bindP (2::Int)]
+
+
+> selectBindIntDoubleString _ = actionBindIntDoubleString
+>   (prefetch 0 sqlBindIntDoubleString [bindP (1::Int), bindP (2.2::Double), bindP "row 1", bindP (3::Int), bindP (4.4::Double), bindP "row 2"])
+
+> selectBindDate _ = actionBindDate
+>   (prefetch 1 sqlBindDate (map bindP expectBindDate))
+
+> selectBindBoundaryDates _ = actionBindBoundaryDates
+>   (prefetch 1 sqlBindBoundaryDates (map bindP expectBoundaryDates))
+
+> selectRebindStmt _ = actionRebind
+>   (prepareQuery "1" (sql sqlRebind) [bindType (0::Int)])
+>   [bindP (1::Int)] [bindP (2::Int)]
+
+> boundStmtDML _ = actionBoundStmtDML
+>   (prepareCommand "boundStmtDML" (sql sqlBoundStmtDML) [bindType (0::Int), bindType ""])
+> boundStmtDML2 _ = do
+>   beginTransaction RepeatableRead
+>   count <- execDML (cmdbind sqlBoundStmtDML [bindP (100::Int), bindP "100"])
+>   rollback
+>   assertEqual sqlBoundStmtDML 1 count
+
+
+> polymorphicFetchTest _ = actionPolymorphicFetch
+>   (prefetch 0 sqlPolymorphicFetch [bindP expectPolymorphicFetch])
+
+> polymorphicFetchTestNull _ = withTransaction RepeatableRead $ 
+>   actionPolymorphicFetchNull (prefetch 1 sqlPolymorphicFetchNull [])
+
+For the exceptionRollback test we have to specify the count result is int4;
+if we don't specify the type then it defaults to a Postgres numeric,
+which we can't yet marshal.
+
+> exceptionRollback _ = actionExceptionRollback sqlInsertTest4
+>   ("select count(*)::int4 from " ++ testTable)
+
+
+Ensure we get an exception if the result-set columns
+don't match the output buffers (at present we only
+check that there aren't too many buffers
+i.e. not enough columns).
+
+> iterateeMatchesResultSet _ = actionIterateeMatchesResultSet
+>   (prefetch 0 sqlIterateeMatchesResultSet [bindP (1::Int), bindP (2.2::Double), bindP "row 1", bindP (3::Int)])
+
+> selectUTF8Text _ = do
+>   let iter (s::String) (_::String) = result s
+>   -- GREEK SMALL LETTER PHI : CF86 UTF8, 03C6 UTF16, 966 decimal
+>   let expect = ['\966']
+>   result <- doQuery (sql ("select '" ++ expect ++ "'")) iter ""
+>   assertEqual "selectUTF8Text" expect result
+
+
+> dropFixtureMultiResultSet1 = "DROP FUNCTION takusenTestFunc()"
+> makeFixtureMultiResultSet1 =
+>   "CREATE OR REPLACE FUNCTION takusenTestFunc() RETURNS SETOF refcursor AS $$"
+>   ++ "DECLARE refc1 refcursor; refc2 refcursor; BEGIN"
+>   ++ "    OPEN refc1 FOR SELECT n*n from t_natural where n < 10 order by 1;"
+>   ++ "    RETURN NEXT refc1;"
+>   ++ "    OPEN refc2 FOR SELECT n, n*n, n*n*n from t_natural where n < 10 order by 1;"
+>   ++ "    RETURN NEXT refc2;"
+>   ++ "END;$$ LANGUAGE plpgsql;\n"
+
+> selectMultiResultSet _ = do
+>   withTransaction RepeatableRead $ do
+>   withPreparedStatement (prepareLargeQuery 2 "stmt1" (sql "select * from takusenTestFunc()") []) $ \pstmt -> do
+>   withBoundStatement pstmt [] $ \bstmt -> do
+>     dummy <- doQuery bstmt iterMain []
+>     result1 <- doQuery (NextResultSet pstmt) iterRS1 []
+>     assertEqual "selectMultiResultSet: RS1" [1,4,9,16,25,36,49,64,81] result1
+>     result2 <- doQuery (NextResultSet pstmt) iterRS2 []
+>     let expect = [(1,1,1),(2,4,8),(3,9,27),(4,16,64),(5,25,125),(6,36,216)
+>           ,(7,49,343),(8,64,512),(9,81,729)]
+>     assertEqual "selectMultiResultSet: RS2" expect result2
+>     return ()
+>   where
+>     iterMain :: (Monad m) => (RefCursor String) -> IterAct m [RefCursor String]
+>     iterMain c acc = result (acc ++ [c])
+>     iterRS1 :: (Monad m) => Int -> IterAct m [Int]
+>     iterRS1 i acc = result (acc ++ [i])
+>     iterRS2 :: (Monad m) => Int -> Int -> Int -> IterAct m [(Int, Int, Int)]
+>     iterRS2 i i2 i3 acc = result (acc ++ [(i, i2, i3)])
+
+
+
+> dropFixtureNestedMultiResultSet1 = "DROP VIEW t_whole"
+> makeFixtureNestedMultiResultSet1 = "CREATE OR REPLACE VIEW t_whole as"
+>   ++ "  select 0 as n union select 1 union select 2 union select 3 union select 4"
+>   ++ " union select 5 union select 6 union select 7 union select 8 union select 9"
+
+> dropFixtureNestedMultiResultSet2 = "DROP VIEW t_natural"
+> makeFixtureNestedMultiResultSet2 = "CREATE OR REPLACE VIEW t_natural as"
+>   ++ " select n from"
+>   ++ " ( select t1.n + 10 * t10.n + 100 * t100.n as n"
+>   ++ "   from t_whole t1, t_whole t10, t_whole t100"
+>   ++ " ) t where n > 0 order by 1"
+
+> dropFixtureNestedMultiResultSet3 = "DROP FUNCTION takusenTestFunc(int4)"
+> makeFixtureNestedMultiResultSet3 =
+>      "CREATE OR REPLACE FUNCTION takusenTestFunc(lim int4) RETURNS refcursor AS $$"
+>   ++ " DECLARE refc refcursor; BEGIN"
+>   ++ "     OPEN refc FOR SELECT n, takusenTestFunc2(n) from t_natural where n < lim order by n;"
+>   ++ "     RETURN refc; END; $$ LANGUAGE plpgsql;"
+
+> dropFixtureNestedMultiResultSet4 = "DROP FUNCTION takusenTestFunc2(int4)"
+> makeFixtureNestedMultiResultSet4 =
+>      "CREATE OR REPLACE FUNCTION takusenTestFunc2(lim int4) RETURNS refcursor AS $$"
+>   ++ " DECLARE refc refcursor; BEGIN"
+>   ++ "     OPEN refc FOR SELECT n from t_natural where n < lim order by n;"
+>   ++ "     RETURN refc; END; $$ LANGUAGE plpgsql;"
+
+> selectNestedMultiResultSet _ = do
+>   let
+>     q = "SELECT n, takusenTestFunc(n) from t_natural where n < 10 order by n"
+>     iterMain   (i::Int) (c::RefCursor String) acc = result' ((i,c):acc)
+>     iterInner  (i::Int) (c::RefCursor String) acc = result' ((i,c):acc)
+>     iterInner2 (i::Int) acc = result' (i:acc)
+>   withTransaction RepeatableRead $ do
+>     rs <- doQuery (sql q) iterMain []
+>     assertEqual "selectNestedMultiResultSet" [9,8,7,6,5,4,3,2,1] (map fst rs)
+>     --print_ ""
+>     flip mapM_ rs $ \(outer, c) -> do
+>       rs <- doQuery c iterInner []
+>       let expect = drop (9-outer) [8,7,6,5,4,3,2,1]
+>       assertEqual "processOuter" expect (map fst rs)
+>       flip mapM_ rs $ \(inner, c) -> do
+>         rs <- doQuery c iterInner2 []
+>         let expect = drop (9-inner) [8,7,6,5,4,3,2,1]
+>         assertEqual "processInner" expect rs
+>         flip mapM_ rs $ \i -> do
+>           --print_ (show outer ++ " " ++ show inner ++ " " ++ show i)
+>           assertBool "processInner2" (i < inner)
+
+
+
+> generateErrorMessageTest _ = do
+>   catchDB ( do
+>       doQuery (sql "select * from nonExistantObject") iterNoRows []
+>       return ()
+>     ) (\e -> do
+>       let msg = formatDBException e
+>       -- uncomment this to view error message
+>       --liftIO (putStrLn msg)
+>       let expect = "42P01 7: ERROR:  42P01: relation"
+>       assertEqual "generateErrorMessageTest" expect (take (length expect) msg)
+>     )
+
+
+> testList :: [PGSqlFunctions -> DBM mark Session ()]
+> testList =
+>   [ selectNoRows, selectTerminatesEarly, selectFloatsAndInts
+>   , selectNullString, selectEmptyString, selectUnhandledNull
+>   , selectNullDate, selectDate, selectCalDate, selectBoundaryDates
+>   , selectCursor, selectExhaustCursor
+>   , selectBindString, selectBindInt, selectBindIntDoubleString
+>   , selectBindDate, selectBindBoundaryDates, selectRebindStmt
+>   , boundStmtDML, boundStmtDML2
+>   , polymorphicFetchTest, polymorphicFetchTestNull, exceptionRollback
+>   , selectMultiResultSet, selectNestedMultiResultSet
+>   , generateErrorMessageTest, selectUTF8Text, iterateeMatchesResultSet
+>   ]
+ Database/PostgreSQL/Test/PGFunctions.lhs view
@@ -0,0 +1,383 @@+
+|
+Module      :  Database.PostgreSQL.Test.PGFunctions
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+
+
+> module Database.PostgreSQL.Test.PGFunctions (runTest) where
+
+
+> import Database.PostgreSQL.PGFunctions
+> import Database.Util
+> import Foreign
+> import Foreign.C
+> import Control.Monad
+> import Control.Exception.Extensible
+> import Data.Dynamic
+> import System.Environment (getArgs)
+> import Test.MiniUnit
+> import Data.Char
+> import Data.Time
+
+
+This low-level test assumes that the user has a database with their name.
+If not, it won't work. I have a postgres user and a postgres database.
+
+> runTest :: String -> IO ()
+> runTest dbname = printPropagateError $ do
+>   testOpen ("user=" ++ dbname)
+>   db <- openDb ("user=" ++ dbname)
+>   disableNoticeReporting db
+>   createFixture db
+>   runTestTT "Postgres low-level tests" (testlist db)
+>   destroyFixture db
+>   closeDb db
+
+> testlist db = map ($ db)
+>   [ testSelectInts
+>   , testSelectDouble
+>   , testSelectDate
+>   , testSelectDate2
+>   , testSelectDate3
+>   , testSelectNumeric
+>   , testSelectStrings
+>   , testSelectInt64
+>   , testSelectNoRows
+>   , testUnion
+>   , testSelectManyRows
+>   , testBindString
+>   , testBindInt
+>   , testBindDouble
+>   , testBindDate
+>   , testCreateDual
+>   , testSelectUTF8Text
+>   ]
+
+
+> ignoreError action = catchPG action (const (return ()))
+
+> printIgnoreError action = catchPG action (putStrLn . show)
+
+> printPropagateError action = catchPG action 
+>     (\e -> putStrLn (show e) >> rethrowPG e)
+
+> ddlExec db stmt = nqExec db stmt >> return ()
+
+> testOpen connstr = openDb connstr >>= closeDb
+
+> createFixture db = do
+>   -- ignoreError $ ddlExec db "drop table tdual"
+>   -- ignoreError $ ddlExec db "drop table t_natural"
+>   -- ignoreError $ ddlExec db "drop table t_blob"
+>   printPropagateError $
+>       ddlExec db "create temp table tdual (dummy text primary key)"
+>   printPropagateError $
+>       ddlExec db "insert into tdual (dummy) values ('X')"
+>   printPropagateError $ ddlExec db 
+>		    "create temp table t_natural (n integer primary key)"
+>   mapM_ (insertNatural db) [1,2,64,65534,65535,65536]
+>   printPropagateError $
+>       ddlExec db "create temp table t_blob (b bytea)"
+>   printPropagateError $
+>       ddlExec db "insert into t_blob values ('blobtest')"
+
+> insertNatural db n = do
+>   ddlExec db $ "insert into t_natural values (" ++ (show n) ++ ")"
+
+
+
+> destroyFixture db = return () -- our tables are temporary
+
+> testCreateDual db = do
+>   ignoreError ( do
+>       ddlExec db "create temp table tdual (dummy integer primary key)"
+>       assertFailure "PGException not thrown when table already exists"
+>     )
+>   printPropagateError $ ddlExec db "insert into tdual values (1)"
+
+
+> testSelectStrings db = do
+>   sn <- printPropagateError $
+>     stmtPrepare db "" "select text(n) from t_natural where n < 3 order by n;" []
+>   (stmt,ntuples) <- stmtExec0t db sn
+>   assertEqual "testSelectInts: ntuples" 2 ntuples
+>   n <- colValString stmt 1 1
+>   assertEqual "testSelectInts: 1" 1 (read n)
+>   n <- colValString stmt 2 1
+>   assertEqual "testSelectInts: 2" 2 (read n)
+>   stmtFinalise stmt
+
+> testSelectInts db = do
+>   sn <- printPropagateError $
+>     stmtPrepare db "" "select n from t_natural where n < 65536 order by n;" []
+>   (rs,ntuples) <- stmtExec0t db sn
+>   assertEqual "testSelectInts: ntuples" 5 ntuples
+>   n <- colValInt rs 1 1
+>   assertEqual "testSelectInts: 1" 1 n
+>   n <- colValInt rs 2 1
+>   assertEqual "testSelectInts: 2" 2 n
+>   n <- colValInt rs 3 1
+>   assertEqual "testSelectInts: 64" 64 n
+>   n <- colValInt rs 4 1
+>   assertEqual "testSelectInts: 65534" 65534 n
+>   stmtFinalise rs
+
+> testSelectInt64 db = do
+>   sn <- printPropagateError $
+>     stmtPrepare db "" "select 20041225235959" []
+>     --stmtPrepare db "" "select -1 union select 1 union select 2*1000*1000*1000 order by 1"
+>   (stmt,ntuples) <- stmtExec0t db sn
+>   n <- colValInt64 stmt 1 1
+>   assertEqual "testSelectInt64: 20041225235959" 20041225235959 n
+>   stmtFinalise stmt
+
+
+> testSelectDouble db = do
+>   sn <- printPropagateError $ stmtPrepare db "" "select 1.2::float8" []
+>   (stmt,ntuples) <- stmtExec0t db sn
+>   n <- colValDouble stmt 1 1
+>   assertEqual "testSelectDouble: 1.2" 1.2 n
+>   stmtFinalise stmt
+
+> testSelectDate db = do
+>   sn <- printPropagateError $ stmtPrepare db ""
+>     ("select timestamp with time zone '2000-01-01'"
+>      ++ " union select timestamp with time zone '2001-01-01'"
+>      ++ " union select timestamp with time zone '1999-01-01' order by 1"
+>     )
+>     []
+>   let
+>     d1 = UTCTime (fromGregorian 1999 1 1) 0
+>     d0 = UTCTime (fromGregorian 2000 1 1) 0
+>     d2 = UTCTime (fromGregorian 2001 1 1) 0
+>     diff1 = realToFrac (diffUTCTime d1 d0)
+>     diff2 = realToFrac (diffUTCTime d2 d0)
+>   (stmt,ntuples) <- stmtExec0t db sn
+>   d <- colValUTCTime stmt 1 1
+>   assertEqual "testSelectDate: 1999" d1 d
+>   d <- colValUTCTime stmt 2 1
+>   assertEqual "testSelectDate: 2000" d0 d
+>   d <- colValUTCTime stmt 3 1
+>   assertEqual "testSelectDate: 2001" d2 d
+>   stmtFinalise stmt
+
+
+Here we test some wierd date boundary cases in Postgres.
+There's some funnyness around 1916-10-01 02:25:20 when we use time zones.
+
+testSelectDate2: 1, -2627156078
+testSelectDate2: 2, -2627156079
+testSelectDate2: 3, -2627156080 (without time zone)
+testSelectDate2: 4, -2627158159 (with time zone)
+diff 3-4: 2080 seconds = 00:34:40
+
+-- Update:
+
+Turns out this is due to my default timezone, which was set to Europe/Dublin
+(some odd things happened to Irish timekeeping at 1916-10-01 02:25:20).
+
+Setting it to GMT (rather than Europe/London or Europe/Dublin) fixed it.
+Note that Europe/London also has some funnyness in 1847,
+so it's also a poor choice if we want to test boundary dates.
+
+
+> testSelectDate2 db = do
+>   let
+>     sqltext =  "select timestamp without time zone '1916-10-01 02:25:22', 10"
+>      ++ " union select timestamp without time zone '1916-10-01 02:25:21', 20"
+>      ++ " union select timestamp without time zone '1916-10-01 02:25:20', 30"
+>      ++ " union select timestamp with time zone '1916-10-01 02:25:20' /* this one fails */, 40"
+>      ++ " order by 2"
+>   sn <- printPropagateError $ stmtPrepare db "" sqltext []
+>   let
+>     ds = (
+>            mkUTCTime 1916 10  1  2 25 22:
+>            mkUTCTime 1916 10  1  2 25 21:
+>            mkUTCTime 1916 10  1  2 25 20:
+>            mkUTCTime 1916 10  1  2 25 20:
+>          [] )
+>   (stmt,ntuples) <- stmtExec0t db sn
+>   let
+>     loop n =
+>       if n <= ntuples
+>         then do
+>         x <- colValDouble stmt n 1
+>         d <- colValUTCTime stmt n 1
+>         assertEqual ("testSelectDate2: " ++ show n ++ "\n" ++ sqltext) (ds!!(n-1)) d
+>         loop (n+1)
+>         else return ()
+>   loop 1
+>   stmtFinalise stmt
+
+
+Postgres only allows specification of -ve years by use of the AD/BC suffix.
+Sadly, this differs from the astronomical year number like so:
+astro: ...  3,  2,  1,  0, -1, -2, -3,...
+ad/bc: ...3AD,2AD,1AD,1BC,2BC,3BC,4BC,...
+
+i.e. 0 astro = 1BC, -1 astro = 2BC, etc.
+
+ISO8601 uses astronomical years, so we ought to be able to write
+-1000-12-25 (instead of 1001-01-01 BC), but Postgres won't parse this.
+
+> testSelectDate3 db = do
+>   let
+>     sqltext =  "select timestamp without time zone '1900-01-01', 10"
+>      ++ " union select timestamp without time zone '1000-01-01', 20"
+>      ++ " union select timestamp without time zone '0001-01-01', 30"
+>      ++ " union select timestamp without time zone '1001-01-01 BC', 40"
+>      ++ " order by 2"
+>   sn <- printPropagateError $ stmtPrepare db "" sqltext []
+>   let
+>     ds =
+>       mkUTCTime 1900 1  1  0 0 0 :
+>       mkUTCTime 1000 1  1  0 0 0 :
+>       mkUTCTime 0001 1  1  0 0 0 :
+>       mkUTCTime (-1000) 1  1  0 0 0 :
+>       []
+>   (stmt,ntuples) <- stmtExec0t db sn
+>   let
+>     loop n =
+>       if n <= ntuples
+>         then do
+>         --x <- colValDouble stmt n 1
+>         d <- colValUTCTime stmt n 1
+>         assertEqual ("testSelectDate3: " ++ show n ++ "\n" ++ sqltext) (ds!!(n-1)) d
+>         loop (n+1)
+>         else return ()
+>   loop 1
+>   stmtFinalise stmt
+
+
+If we don't specify the type, Postgres gives the number the NUMERIC type.
+I don't yet know what the internal binary rep is, nor how to
+convert it to an appropriate Haskell type.
+Best we can do is marshal/transmist everything as text.
+
+> testSelectNumeric db = do
+>   sn <- printPropagateError $ stmtPrepare db "" "select 1.2" []
+>   (rs,ntuples) <- stmtExec0t db sn
+>   --fmt0 <- fPQfformat rs 0
+>   --ct0  <- fPQftype rs 0
+>   --putStrLn $ "\ntestSelectNumeric: format " ++ (show fmt0) ++ ", type (oid) " ++ (show ct0)
+>   n <- colValDouble rs 1 1
+>   assertEqual "testSelectNumeric: 1.2" 1.2 n
+>   stmtFinalise rs
+
+
+
+> testUnion db = do
+>   (stmt,ntuples) <- printPropagateError $
+>     stmtExecImm db "select 'h1' from tdual union select 'h2' from tdual union select 'h3' from tdual" []
+>   assertEqual "testUnion: ntuples" 3 ntuples
+>   s <- colValString stmt 1 1
+>   assertEqual "testUnion: h1" "h1" s
+>   s <- colValString stmt 2 1
+>   assertEqual "testUnion: h2" "h2" s
+>   s <- colValString stmt 3 1
+>   assertEqual "testUnion: h3" "h3" s
+>   stmtFinalise stmt
+
+
+> testSelectNoRows db = do
+>   (stmt,ntuples) <- printPropagateError $
+>     stmtExecImm db "select 'h1' from tdual where dummy = '2'" []
+>   stmtFinalise stmt
+>   assertEqual "testSelectNoRows: done" 0 ntuples
+
+
+> manyRows :: String
+> manyRows = 
+>   "select 1 from"
+>   ++ "  ( select 1 from tdual union select 0 from tdual) as t1"
+>   ++ ", ( select 2 from tdual union select 0 from tdual) as t2"
+>   ++ ", ( select 3 from tdual union select 0 from tdual) as t3"
+>   ++ ", ( select 4 from tdual union select 0 from tdual) as t4"
+>   ++ ", ( select 5 from tdual union select 0 from tdual) as t5"
+>   ++ ", ( select 6 from tdual union select 0 from tdual) as t6"
+>   ++ ", ( select 7 from tdual union select 0 from tdual) as t7"
+>   ++ ", ( select 8 from tdual union select 0 from tdual) as t8"
+>   ++ ", ( select 9 from tdual union select 0 from tdual) as t9"
+>   ++ ", ( select 10 from tdual union select 0 from tdual) as t10"
+
+
+> countRows :: DBHandle -> String -> Int -> IO Int
+> countRows db sn n = do
+>   (stmt,ntuples) <- printPropagateError $ stmtExec0t db sn
+>   stmtFinalise stmt
+>   if ntuples == 0
+>     then return n
+>     else countRows db sn (n+ntuples)
+
+> cursor'name = "takusenp"
+
+> testSelectManyRows db = do
+>   let prefetch = 200
+>   _ <- printPropagateError $ nqExec db "Begin work"
+>   let q = "DECLARE " ++ cursor'name ++ " NO SCROLL CURSOR FOR " ++
+>		  manyRows
+>   _ <- printPropagateError $ nqExec db q
+>   let f = "FETCH FORWARD " ++ (show prefetch) ++ " FROM " ++ cursor'name
+>   sn <- printPropagateError $ stmtPrepare db "" f []
+>   n <- countRows db sn 0
+>   _ <- printPropagateError $ nqExec db $ "CLOSE " ++ cursor'name
+>   _ <- printPropagateError $ nqExec db $ "commit work"
+>   assertEqual "testSelectManyRows: done" 1024 n
+
+
+> testBindString db = do
+>   (rs, ntuples) <- printPropagateError $
+>     prepare'n'exec db "" (substituteBindPlaceHolders "select ?") [newBindVal "h1"]
+>   n <- colValString rs 1 1
+>   assertEqual "testBindString: h1" "h1" n
+>   stmtFinalise rs
+
+> testBindInt db = do
+>   (rs, ntuples) <- printPropagateError $
+>     prepare'n'exec db "" (substituteBindPlaceHolders "select ?") [newBindVal (2001::Int)]
+>   n <- colValInt rs 1 1
+>   assertEqual "testBindInt: 2001" 2001 n
+>   stmtFinalise rs
+
+> testBindDouble db = do
+>   let
+>     v1 :: Double; v1 = 2.3
+>     v2 :: Int; v2 = 2001
+>     v3 :: Int; v3 = 2001
+>     bindvals = [newBindVal v1, newBindVal v2, newBindVal v3]
+>   (rs, ntuples) <- printPropagateError $ do
+>     prepare'n'exec db "" (substituteBindPlaceHolders "select ? from tdual where ? = ?") bindvals
+>   n <- colValDouble rs 1 1
+>   assertEqual "testBindDouble: 2.3" 2.3 n
+>   stmtFinalise rs
+
+> testBindDate db = do
+>   let
+>     v1 :: UTCTime; v1 = UTCTime (fromGregorian 2000 1 1) 0
+>     v2 :: UTCTime; v2 = UTCTime (fromGregorian 1980 2 29) 0
+>     bindvals = [newBindVal v1, newBindVal v2]
+>   (rs, ntuples) <- printPropagateError $
+>     prepare'n'exec db "" (substituteBindPlaceHolders "select ?, ?") bindvals
+>   n <- colValUTCTime rs 1 1
+>   assertEqual "testBindDate: 1 " v1 n
+>   n <- colValUTCTime rs 1 2
+>   assertEqual "testBindDate: 2 " v2 n
+>   stmtFinalise rs
+
+> testSelectUTF8Text db = do
+>   -- GREEK SMALL LETTER PHI
+>   -- unicode code-point 966
+>   -- UTF8: CF86 (207,134)
+>   -- UTF16: 03C6
+>   let expect = ['\966']
+>   let sql = "select '" ++ expect ++ "'"
+>   sn <- printPropagateError (stmtPrepare db "" sql [])
+>   (stmt,ntuples) <- stmtExec0t db sn
+>   assertEqual "testSelectUTF8Text: ntuples" 1 ntuples
+>   result <- colValString stmt 1 1
+>   assertEqual "testSelectUTF8Text" expect result
+
+ Database/PostgreSQL/Test/pgaccess.hs view
@@ -0,0 +1,188 @@+{-# OPTIONS -fglasgow-exts #-}++module Main where++import System.Environment (getArgs)+import Control.Exception (try, handle, bracket, throwIO)+import System.IO+import Data.List (isPrefixOf)+import Data.Char (toLower)+import System.Posix (epochTime,ProcessID,getProcessID,EpochTime)+import Database.PostgreSQL.PGFunctions+import Prelude hiding (log)++docstrings = [+ "A helper to access a PostgreSQL from a `scripting' language.",+ "This function attempts to closely emulate `dbaccess' of Informix.",+ "The goal is to have my Scheme-to-Informix interface work with",+ "PostgreSQL with minimal changes.",+ "",+ "Synopsys:",+ "   dbaccess <conn-parms>",+ "where <conn-parms> is the string of database connection parameters.",+ "",+ "The program connects to the database and listens on its standard",+ "input for a SQL command. A command is an ASCII sequence terminated by",+ "NL-NULL-NL.",+ "If the command is other than SELECT or COPY, we submit it to the database.",+ "On success, no reply is generated, and we wait for a new command.",+ "If the command starts with a /*simple*/ SELECT, we expect few rows.",+ "We submit the query to the database and write the result to stdout.",+ "If the command was SELECT, we make a query and write the result,",+ "in groups, to the stdout. Each group of results has the form:",+ "  0 NL",+ " for the last group of results",+ " <nrows> <space> <ncols> NL",+ " followed by the matrix of <nrows> * <ncols> field values in the",+ " row-major order. Each field value has the form",+ " <length>NL<value>",+ " where <length> is the length of the value proper (no NL).",+ "",+ "If the command was COPY, we assume ",+ "   COPY /*<len> fname*/ table ... FROM STDIN...",+ " where <len> is the length of the file name. We open the file and",+ " send its contents to the server",+ "",+ "Any error causes the termination of this program.",+ "We log all the results to stderr."+ ]+++main = do+       args <- getArgs+       hSetBuffering stderr LineBuffering+       hSetBuffering stdout LineBuffering+       case args of+		 [connparms] -> main' connparms+		 _ -> mapM_ err'note ("One argument is expected" :+				      docstrings)++err'note = hPutStrLn stderr++data Log = Log { log_pid :: ProcessID, log_time :: EpochTime }++log log_data strs = err'note (show (log_time log_data) +++			      " [" ++ show (log_pid log_data) ++ "] " +++			      concat strs)++main' connparms =+    do+    pid <- getProcessID+    etime <- epochTime+    let logd = Log pid etime+    catchPG (+	     bracket (openDb connparms) closeDb $ \db ->+	       log logd ["Starting"] >>+	       -- setErrorVerbosity db ePQERRORS_VERBOSE+	       main'' logd stdin db stdout)+	    (\e -> err'note (show e) >> rethrowPG e)+++data CommandCategory = +    CmdQuery | CmdSimpleQuery String | CmdCopy FilePath String | CmdOther++-- Main loop proper+main'' logd hin db hout =+    do+    cmd <- get'command hin ""+    logd <- epochTime >>= (\et -> return logd{log_time=et})+    log logd ["SQL: ",cmd]+    case classify cmd of+		      CmdQuery -> exec'complex'query logd cmd db hout+		      CmdSimpleQuery cmd -> +			  exec'simple'query logd cmd db hout+		      CmdOther -> exec'other logd cmd db hout+		      CmdCopy fname cmd -> exec'copy logd cmd db fname+    hFlush hout+    main'' logd hin db hout+ where+ get'command hin acc = do +		       s <- hGetLine hin+		       if s == "\NUL" then return acc +			  else get'command hin (acc ++ s ++ "\n")+ psimple = "/*simple*/"+ classify cmd | isPrefixOf psimple cmd = CmdSimpleQuery +					      (drop (length psimple) cmd)+ classify cmd | isPrefixOfci "select" cmd = CmdQuery+ classify cmd | isPrefixOfci "copy"   cmd = +		  let (fname,s) = read'fname $ snd (break (== '/') cmd)+		  in CmdCopy fname ("copy " ++ s)+ classify _ = CmdOther++ read'fname ('/':'*':str) = let [(l::Int,' ':s)] = reads str+				fname = take l s+				('*':'/':s') = drop l s+			    in (fname,s')++ -- case-insensitive+ isPrefixOfci [] _ = True+ isPrefixOfci _ [] = False+ isPrefixOfci (cp:rp) (cs:rs) | (toLower cp == toLower cs) =+				  isPrefixOfci rp rs+ isPrefixOfci _ _ = False+++-- ------------------------------------------------------------------------+-- Executors++nrows_in_a_group = 10 -- aka, the prefetch count+cursor_name = "pgaccessc"++-- A general query: may return too many rows. So, we have to open+-- a cursor and query by groups+exec'complex'query logd cmd db hout = +    do+    nqExec db $ unwords ["DECLARE",cursor_name,"NO SCROLL CURSOR FOR",cmd]+    let fetchq = unwords ["FETCH FORWARD",show nrows_in_a_group,"FROM",+			  cursor_name]+    psname <- stmtPrepare db "" fetchq []+    let loop = do+	       (rs,ntuples) <- stmtExec0t db psname+	       log logd ["SQLtuples...: ",show ntuples]+	       put'tuples rs ntuples hout+	       stmtFinalise rs+	       if ntuples == 0 then return () else loop+    loop+    nqExec db $ unwords ["CLOSE",cursor_name]+    return ()++++-- execute a query that is expected to produce few values.+-- That is, we're justified in asking for all tuples and so can get+-- by without opening a cursor, etc.+exec'simple'query logd cmd db hout = +    do+    (rs,ntuples) <- stmtExecImm0 db cmd+    log logd ["SQLtuples: ",show ntuples]+    put'tuples rs ntuples hout+    stmtFinalise rs++put'tuples rs ntuples hout =+    if ntuples == 0 then hPutStrLn hout "0" else put'tuples'+ where+ put'tuples' = do+	       ncols <- fPQnfields rs+	       hPutStrLn hout $ unwords [show ntuples,show ncols]+	       sequence_ [put'col i j | i<-[0..ntuples-1], j<-[0..ncols-1]]+ put'col i j = do+	       len <- fPQgetlength rs (fromIntegral i) (fromIntegral j)+	       hPutStrLn hout $ show len+	       vp  <- fPQgetvalue rs (fromIntegral i) (fromIntegral j)+	       hPutBuf hout vp (fromIntegral len)+++-- Execute command (such as DDL or DML) that produces no resultset+exec'other logd cmd db hout = +    do+    res <- nqExec db cmd+    log logd ["SQLDone: ", show res]++-- Execute the COPY FROM STDIN command+exec'copy logd cmd db fname = +    do+    log logd ["SQLCopy: ", fname]+    hin <- openBinaryFile fname ReadMode+    nqCopyIn db cmd hin+    hClose hin+    log logd ["SQLCopyDone"]
Database/Sqlite/Enumerator.lhs view
@@ -11,9 +11,15 @@ 
 
 > {-# OPTIONS -fglasgow-exts #-}
-> {-# OPTIONS -fallow-undecidable-instances #-}
-> {-# OPTIONS -fallow-overlapping-instances #-}
 
+> {-# LANGUAGE OverlappingInstances #-}
+> {-# LANGUAGE UndecidableInstances #-}
+> {-# LANGUAGE IncoherentInstances #-}
+> {-# LANGUAGE FlexibleInstances #-}
+> {-# LANGUAGE MultiParamTypeClasses #-}
+> {-# LANGUAGE TypeSynonymInstances #-}
+
+
 > module Database.Sqlite.Enumerator
 >   ( Session, connect
 >   , prepareStmt, preparePrefetch
@@ -31,7 +37,7 @@ > import Database.Util
 > import Foreign.C
 > import Control.Monad
-> import Control.Exception
+> import Control.Exception.Extensible
 > import Database.Sqlite.SqliteFunctions
 >   (DBHandle, StmtHandle, SqliteException(..), catchSqlite, throwSqlite)
 > import qualified Database.Sqlite.SqliteFunctions as DBAPI
@@ -155,11 +161,13 @@ 
 > instance Command String Session where
 >   executeCommand sess str = do
->     stmt <- stmtPrepare (dbHandle sess) str
->     fetchRow (dbHandle sess) stmt
->     n <- DBAPI.stmtChanges (dbHandle sess)
->     finaliseStmt (dbHandle sess) stmt
->     return (fromIntegral n)
+>     bracket 
+>       (stmtPrepare (dbHandle sess) str)
+>       (finaliseStmt (dbHandle sess))
+>       (\stmt -> do
+>         fetchRow (dbHandle sess) stmt
+>         liftM fromIntegral (DBAPI.stmtChanges (dbHandle sess))
+>       )
 
 > instance Command BoundStmt Session where
 >   executeCommand sess (BoundStmt pstmt) = do
@@ -171,13 +179,14 @@ 
 > instance Command StmtBind Session where
 >   executeCommand sess (StmtBind sqltext bas) = do
->     let (PreparationA action) = prepareStmt' sqltext False
->     pstmt <- action sess
->     sequence_ (zipWith (\i (BindA ba) -> ba sess pstmt i) [1..] bas)
->     fetchRow (dbHandle sess) (stmtHandle pstmt)
->     n <- DBAPI.stmtChanges (dbHandle sess)
->     finaliseStmt (dbHandle sess) (stmtHandle pstmt)
->     return (fromIntegral n)
+>     bracket
+>       (let (PreparationA action) = prepareStmt' sqltext False in action sess)
+>       (finaliseStmt (dbHandle sess) . stmtHandle)
+>       (\pstmt -> do
+>         sequence_ (zipWith (\i (BindA ba) -> ba sess pstmt i) [1..] bas)
+>         fetchRow (dbHandle sess) (stmtHandle pstmt)
+>         liftM fromIntegral (DBAPI.stmtChanges (dbHandle sess))
+>       )
 
 
 > data LastInsertRowid = LastInsertRowid
Database/Sqlite/SqliteFunctions.lhs view
@@ -1,6 +1,4 @@ 
-> {-# OPTIONS -ffi -fglasgow-exts #-}
-
 |
 Module      :  Database.Sqlite.SqliteFunctions
 Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
@@ -12,14 +10,18 @@ Simple wrappers for Sqlite functions (FFI).
 
 
+> {-# LANGUAGE ForeignFunctionInterface #-}
+> {-# LANGUAGE CPP #-}
+
 > module Database.Sqlite.SqliteFunctions where
 
+> import Prelude hiding (catch)
 > import Foreign.C.UTF8
 > import Foreign
 > import Foreign.C
 > import Foreign.Ptr
 > import Control.Monad
-> import Control.Exception
+> import Control.Exception.Extensible
 > import Data.Dynamic
 > import Data.Int
 
@@ -40,10 +42,11 @@ >   show (SqliteException i s) = "SqliteException " ++ (show i) ++ " " ++ s
 
 > catchSqlite :: IO a -> (SqliteException -> IO a) -> IO a
-> catchSqlite = catchDyn
-
 > throwSqlite :: SqliteException -> a
-> throwSqlite = throwDyn
+> instance Exception SqliteException
+> catchSqlite = catch
+> throwSqlite = throw
+
 
 > sqliteOK :: CInt
 > sqliteOK = 0
+ Database/Sqlite/Test/Enumerator.lhs view
@@ -0,0 +1,158 @@+
+|
+Module      :  Database.Sqlite.Test.Enumerator
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+
+
+> {-# LANGUAGE OverlappingInstances #-}
+
+> module Database.Sqlite.Test.Enumerator (runTest) where
+
+> import qualified Database.Sqlite.Test.SqliteFunctions as Low
+> import Database.Sqlite.Enumerator
+> import Database.Test.Performance as Perf
+> import Database.Test.Enumerator
+> import Control.Monad (when)
+> import Control.Monad.Trans (liftIO)
+> import Test.MiniUnit
+> import Data.Int
+> import System.Time
+
+
+> runTest :: Perf.ShouldRunTests -> [String] -> IO ()
+> runTest runPerf args = do
+>   let (user:pswd:dbname:_) = args
+>   Low.runTest dbname
+>   flip catchDB basicDBExceptionReporter $ do
+>     (r, conn1) <- withContinuedSession (connect dbname) (testBody runPerf)
+>     withSession conn1 testPartTwo
+
+> testBody runPerf = do
+>   runFixture SqliteFunctions
+>   when (runPerf == Perf.RunTests) runPerformanceTests
+
+> testPartTwo :: DBM mark Session ()
+> testPartTwo = do
+>   makeFixture execDrop execDDL_
+>   destroyFixture execDDL_
+
+> runPerformanceTests = do
+>   makeFixture execDrop execDDL_
+>   beginTransaction RepeatableRead
+>   {-# SCC "runPerformanceTests:runTestTT" #-}
+>    runTestTT "Sqlite performance tests" (map (flip catchDB reportRethrow)
+>     [ timedSelect (prefetch 1000 sqlRows2Power20 []) 35 (2^20)
+>     , timedSelect (prefetch 1 sqlRows2Power17 []) 4 (2^17)
+>     , timedSelect (prefetch 1000 sqlRows2Power17 []) 4 (2^17)
+>     , timedCursor (prefetch 1 sqlRows2Power17 []) 4 (2^17)
+>     , timedCursor (prefetch 1000 sqlRows2Power17 []) 4 (2^17)
+>     ]
+>     )
+>   commit
+>   destroyFixture execDDL_
+
+
+> runFixture :: DBLiteralValue a => a -> DBM mark Session ()
+> runFixture fns = do
+>   makeFixture execDrop execDDL_
+>   runTestTT "Sqlite tests" (map (runOneTest fns) testList)
+>   destroyFixture execDDL_
+
+> runOneTest fns t = catchDB (t fns) reportRethrow
+
+-----------------------------------------------------------
+
+> selectNoRows _ = selectTest sqlNoRows iterNoRows expectNoRows
+
+> selectTerminatesEarly _ = selectTest sqlTermEarly iterTermEarly expectTermEarly
+
+> selectFloatsAndInts fns = selectTest (sqlFloatsAndInts fns) iterFloatsAndInts expectFloatsAndInts
+
+> selectNullString _ = selectTest sqlNullString iterNullString expectNullString
+
+> selectEmptyString _ = selectTest sqlEmptyString iterEmptyString expectEmptyString
+
+> selectUnhandledNull _ = catchDB ( do
+>       selectTest sqlUnhandledNull iterUnhandledNull expectUnhandledNull
+>       assertFailure sqlUnhandledNull
+>   ) (\e -> return () )
+
+
+
+> selectNullDate dateFn = selectTest (sqlNullDate dateFn) iterNullDate expectNullDate
+
+> selectDate dateFn = selectTest (sqlDate dateFn) iterDate expectDate
+
+> selectCalDate dateFn = selectTest (sqlDate dateFn) iterCalDate expectCalDate
+
+> selectBoundaryDates dateFn = selectTest (sqlBoundaryDates dateFn) iterBoundaryDates expectBoundaryDates
+
+> selectCursor fns = actionCursor (sqlCursor fns)
+> selectExhaustCursor fns = actionExhaustCursor (sqlCursor fns)
+
+> selectBindString _ = actionBindString
+>     (prepareQuery (sql sqlBindString))
+>     [bindP "a2", bindP "b1"]
+
+> selectBindInt _ = actionBindInt
+>   (prepareQuery (sql sqlBindInt))
+>   [bindP (1::Int), bindP (2::Int)]
+
+
+> selectBindIntDoubleString _ = actionBindIntDoubleString
+>   (prefetch 1 sqlBindIntDoubleString [bindP (1::Int), bindP (2.2::Double), bindP "row 1", bindP (3::Int), bindP (4.4::Double), bindP "row 2"])
+
+> selectBindDate _ = actionBindDate
+>   (prefetch 1 sqlBindDate (map bindP expectBindDate))
+
+> selectBindBoundaryDates _ = actionBindBoundaryDates
+>   (prefetch 1 sqlBindBoundaryDates (map bindP expectBoundaryDates))
+
+> selectRebindStmt _ = actionRebind (prepareQuery (sql sqlRebind))
+>    [bindP (1::Int)] [bindP (2::Int)]
+
+> boundStmtDML _ = actionBoundStmtDML (prepareCommand (sql sqlBoundStmtDML))
+> boundStmtDML2 _ = do
+>   -- cannot use withTransaction with rollback/commit;
+>   -- if you explicitly end the transaction, then when withTransaction
+>   -- attempts to end it (with a commit, in the success case) then we
+>   -- get a "logic error".
+>   -- This differs from PostgreSQL and Oracle, who don't seem to care if
+>   -- you commit or rollback too many times.
+>   beginTransaction RepeatableRead
+>   count <- execDML (cmdbind sqlBoundStmtDML [bindP (100::Int), bindP "100"])
+>   rollback
+>   assertEqual sqlBoundStmtDML 1 count
+
+> polymorphicFetchTest _ = actionPolymorphicFetch
+>   (prefetch 1 sqlPolymorphicFetch [bindP expectPolymorphicFetch])
+
+> polymorphicFetchTestNull _ = actionPolymorphicFetchNull
+>   (prefetch 1 sqlPolymorphicFetchNull [])
+
+> exceptionRollback _ = actionExceptionRollback sqlInsertTest4 sqlExceptionRollback
+
+> insertGetRowId _ =
+>   withTransaction RepeatableRead ( do
+>     execDML (sql ("insert into " ++ testTable ++ " values (100, '100')"))
+>     rowid <- inquire LastInsertRowid
+>     assertBool "insertGetRowId" (rowid > 0)
+>     --liftIO $ putStrLn ("last insert row id " ++ show rowid)
+>   )
+
+> testList :: DBLiteralValue a => [a -> DBM mark Session ()]
+> testList =
+>   [ selectNoRows, selectTerminatesEarly, selectFloatsAndInts
+>   , selectNullString, selectEmptyString, selectUnhandledNull
+>   , selectNullDate, selectDate, selectCalDate, selectBoundaryDates
+>   , selectCursor, selectExhaustCursor
+>   , selectBindString, selectBindInt, selectBindIntDoubleString
+>   , selectBindDate, selectBindBoundaryDates, selectRebindStmt
+>   , boundStmtDML, boundStmtDML2
+>   , polymorphicFetchTest, polymorphicFetchTestNull, exceptionRollback
+>   , insertGetRowId
+>   ]
+ Database/Sqlite/Test/SqliteFunctions.lhs view
@@ -0,0 +1,291 @@+
+|
+Module      :  Database.Sqlite.Test.SqliteFunctions
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+
+
+> module Database.Sqlite.Test.SqliteFunctions (runTest) where
+
+
+> import Foreign
+> import Foreign.C
+> import Foreign.C.UTF8
+> import Control.Monad
+> import Control.Exception.Extensible
+> import Data.Dynamic
+> import Database.Sqlite.SqliteFunctions
+> import System.Environment (getArgs)
+> import Test.MiniUnit
+
+
+
+
+> runTest :: String -> IO ()
+> runTest dbname = do
+>   testOpen dbname
+>   db <- openDb dbname
+>   createFixture db
+>   runTestTT "Sqlite low-level tests" (testlist db)
+>   destroyFixture db
+>   closeDb db
+
+
+> --testlist db = TestList $ map (\t -> TestCase (t db))
+> testlist db = map (\t -> t db)
+>   [ testSelectInts
+>   , testSelectDouble
+>   , testSelectInt64
+>   , testSelectStringNull
+>   , testSelectStringEmpty
+>   , testSelectNoRows
+>   , testSelectManyRows
+>   , testUnion
+>   , testBindString
+>   , testBindDouble
+>   , testFetchAfterFinalise
+>   , testConstraintError
+>   , testSelectUTF8Text
+>   ]
+
+
+> ignoreError action =
+>   catchSqlite action (\e -> return undefined)
+
+> printIgnoreError action = catchSqlite action 
+>     (\e -> do
+>       putStrLn (show e)
+>       return undefined
+>     )
+
+> printPropagateError action = catchSqlite action 
+>     (\e -> do
+>       putStrLn (show e)
+>       throwSqlite e
+>       return undefined
+>     )
+
+> ddlExec db stmt = do
+>   _ <- stmtExec db stmt
+>   return ()
+
+> testOpen dbname = do
+>   h <- openDb dbname
+>   closeDb h
+
+> createFixture db = do
+>   ignoreError $ ddlExec db "drop table tdual"
+>   ignoreError $ ddlExec db "drop table t_natural"
+>   ignoreError $ ddlExec db "drop table t_blob"
+>   printPropagateError $
+>       ddlExec db "create table tdual (dummy text)"
+>   printPropagateError $
+>       ddlExec db "insert into tdual (dummy) values ('X')"
+>   printPropagateError $ ddlExec db "create table t_natural (n integer primary key)"
+>   mapM_ (insertNatural db) [1..10]
+>   printPropagateError $
+>       ddlExec db "create table t_blob (b blob)"
+>   printPropagateError $
+>       ddlExec db "insert into t_blob values ('blobtest')"
+
+> insertNatural db n = do
+>   ddlExec db $ "insert into t_natural values (" ++ (show n) ++ ")"
+
+
+
+> destroyFixture db = do
+>   printPropagateError $ ddlExec db "drop table tdual"
+>   printPropagateError $ ddlExec db "drop table t_natural"
+>   printPropagateError $ ddlExec db "drop table t_blob"
+
+
+> testCreateDual db = do
+>   ignoreError ( do
+>       ddlExec db "create table tdual (dummy integer primary key)"
+>       assertFailure "SqliteException not thrown when table already exists"
+>     )
+>   printPropagateError $ ddlExec db "insert into tdual values (1)"
+
+
+
+
+> testSelectInts db = do
+>   stmt <- printPropagateError $
+>     stmtPrepare db "select n from t_natural where n < 3 order by n;"
+>   rc <- stmtFetch db stmt
+>   n <- colValInt stmt 1
+>   assertEqual "testSelectInts: 1" 1 n
+>   rc <- stmtFetch db stmt
+>   n <- colValInt stmt 1
+>   assertEqual "testSelectInts: 2" 2 n
+>   rc <- stmtFetch db stmt
+>   stmtFinalise db stmt
+>   assertEqual "testSelectInts: done" sqliteDONE rc
+
+
+> testSelectInt64 db = do
+>   stmt <- printPropagateError $
+>     stmtPrepare db "select 20041225235959"
+>     --stmtPrepare db "select -1 union select 1 union select 2*1000*1000*1000 order by 1"
+>   rc <- stmtFetch db stmt
+>   n <- colValInt64 stmt 1
+>   assertEqual "testSelectInt64: 20041225235959" 20041225235959 n
+>   rc <- stmtFetch db stmt
+>   stmtFinalise db stmt
+>   assertEqual "testSelectInt64: done" sqliteDONE rc
+
+
+> testSelectDouble db = do
+>   stmt <- printPropagateError $
+>     stmtPrepare db "select 1.2"
+>   rc <- stmtFetch db stmt
+>   n <- colValDouble stmt 1
+>   assertEqual "testSelectDouble: 1.2" 1.2 n
+>   rc <- stmtFetch db stmt
+>   stmtFinalise db stmt
+>   assertEqual "testSelectDouble: done" sqliteDONE rc
+
+
+> testSelectStringNull db = do
+>   stmt <- printPropagateError $
+>     stmtPrepare db "select null"
+>   rc <- stmtFetch db stmt
+>   n <- colValString stmt 1
+>   assertEqual "testSelectString: Nothing" Nothing n
+>   rc <- stmtFetch db stmt
+>   stmtFinalise db stmt
+>   assertEqual "testSelectString: done" sqliteDONE rc
+
+
+> testSelectStringEmpty db = do
+>   stmt <- printPropagateError $
+>     stmtPrepare db "select ''"
+>   rc <- stmtFetch db stmt
+>   -- what is rc after row fetch? sqliteOK or sqliteROW?
+>   assertEqual "testSelectString: row 1" sqliteROW rc
+>   n <- colValString stmt 1
+>   assertEqual "testSelectString: ''" (Just "") n
+>   rc <- stmtFetch db stmt
+>   stmtFinalise db stmt
+>   assertEqual "testSelectString: done" sqliteDONE rc
+
+
+> testUnion db = do
+>   stmt <- printPropagateError $
+>     stmtPrepare db "select 'h1' from tdual union select 'h2' from tdual union select 'h3' from tdual"
+>   rc <- stmtFetch db stmt
+>   Just s <- colValString stmt 1
+>   assertEqual "testUnion: h1" "h1" s
+>   rc <- stmtFetch db stmt
+>   Just s <- colValString stmt 1
+>   assertEqual "testUnion: h2" "h2" s
+>   rc <- stmtFetch db stmt
+>   Just s <- colValString stmt 1
+>   assertEqual "testUnion: h3" "h3" s
+>   rc <- stmtFetch db stmt
+>   stmtFinalise db stmt
+>   assertEqual "testUnion: done" sqliteDONE rc
+
+
+> testSelectNoRows db = do
+>   stmt <- printPropagateError $
+>     stmtPrepare db "select 'h1' from tdual where dummy = '2'"
+>   rc <- stmtFetch db stmt
+>   stmtFinalise db stmt
+>   assertEqual "testSelectNoRows: done" sqliteDONE rc
+
+
+> manyRows :: String
+> manyRows = 
+>   "select 1 from"
+>   ++ "  ( select 1 from tdual union select 0 from tdual)"
+>   ++ ", ( select 2 from tdual union select 0 from tdual)"
+>   ++ ", ( select 3 from tdual union select 0 from tdual)"
+>   ++ ", ( select 4 from tdual union select 0 from tdual)"
+>   ++ ", ( select 5 from tdual union select 0 from tdual)"
+>   ++ ", ( select 6 from tdual union select 0 from tdual)"
+>   ++ ", ( select 7 from tdual union select 0 from tdual)"
+>   ++ ", ( select 8 from tdual union select 0 from tdual)"
+>   ++ ", ( select 9 from tdual union select 0 from tdual)"
+>   ++ ", ( select 10 from tdual union select 0 from tdual)"
+
+
+> countRows :: DBHandle -> StmtHandle -> Int -> IO Int
+> countRows db stmt n = do
+>   rc <- printPropagateError $ stmtFetch db stmt
+>   _ <- colValInt stmt 1
+>   if rc == sqliteDONE
+>     then return n
+>     else countRows db stmt (n+1)
+
+> testSelectManyRows db = do
+>   stmt <- printPropagateError $ stmtPrepare db manyRows
+>   n <- countRows db stmt 0
+>   stmtFinalise db stmt
+>   assertEqual "testSelectManyRows: done" 1024 n
+
+> testBindString db = do
+>   stmt <- printPropagateError $
+>     stmtPrepare db "select ? from tdual"
+>   bindString db stmt 1 "h1"
+>   rc <- stmtFetch db stmt
+>   Just n <- colValString stmt 1
+>   assertEqual "testBindString: h1" "h1" n
+>   rc <- stmtFetch db stmt
+>   stmtFinalise db stmt
+
+> testBindDouble db = do
+>   stmt <- printPropagateError $
+>     stmtPrepare db "select ? from tdual where ? = ?"
+>   bindDouble db stmt 1 2.3
+>   bindInt db stmt 2 2001
+>   bindInt64 db stmt 3 2001
+>   rc <- stmtFetch db stmt
+>   n <- colValDouble stmt 1
+>   assertEqual "testBindDouble: 2.3" 2.3 n
+>   rc <- stmtFetch db stmt
+>   stmtFinalise db stmt
+
+
+This test reveals that library misuse (error number 21)
+is reported by sqlite_errcode as error code zero.
+
+> testFetchAfterFinalise db = do
+>   stmt <- printPropagateError $ stmtPrepare db manyRows
+>   stmtFinalise db stmt
+>   rc <- sqliteStep stmt
+>   assertEqual "testFetchAfterFinalise: rc" 21 rc
+>   ex@(SqliteException e m) <- getError db
+>   -- Is this a bug in Sqlite?)
+>   assertEqual "testFetchAfterFinalise: errcode" 0 e
+>   assertEqual "testFetchAfterFinalise: errmsg" "not an error" m
+
+
+This test confirms that a constraint error (19)
+is correctly reported by sqlite_errcode.
+
+> testConstraintError db = do
+>   withUTF8String "insert into t_natural values (1)" $ \cstr -> do
+>   rc <- sqliteExec db cstr nullFunPtr nullPtr nullPtr
+>   assertEqual "testConstraintError: rc" 19 rc
+>   ex@(SqliteException e m) <- getError db
+>   assertEqual "testConstraintError: errcode" 19 e
+>   assertEqual "testConstraintError: errmsg" "PRIMARY KEY must be unique" m
+
+
+> testSelectUTF8Text db = do
+>   -- GREEK SMALL LETTER PHI
+>   -- unicode code-point 966
+>   -- UTF8: CF86 (207,134)
+>   -- UTF16: 03C6
+>   let expect = ['\966']
+>   stmt <- printPropagateError $
+>     stmtPrepare db "select ?"
+>   bindString db stmt 1 expect
+>   rc <- stmtFetch db stmt
+>   Just n <- colValString stmt 1
+>   assertEqual "testSelectUTF8Text" expect n
+>   stmtFinalise db stmt
Database/Stub/Enumerator.lhs view
@@ -16,10 +16,12 @@ See fetchIntVal.
 
 
-
 > {-# OPTIONS -fglasgow-exts #-}
-> {-# OPTIONS -fallow-undecidable-instances #-}
-> {-# OPTIONS -fallow-overlapping-instances #-}
+> {-# LANGUAGE OverlappingInstances #-}
+> {-# LANGUAGE UndecidableInstances #-}
+> {-# LANGUAGE MultiParamTypeClasses #-}
+> {-# LANGUAGE FlexibleInstances #-}
+> {-# LANGUAGE IncoherentInstances #-}
 
 > module Database.Stub.Enumerator
 >   -- Only the type constructor of Session is exported
@@ -35,7 +37,6 @@ > import Foreign.C
 > import Foreign.C.Types
 > import Control.Monad
-> import Control.Exception (catchDyn, throwDyn, throwIO)
 > import System.Time
 > import Data.IORef
 > import Data.Dynamic
+ Database/Stub/Test/Enumerator.lhs view
@@ -0,0 +1,179 @@+
+|
+Module      :  Database.Stub.Test.Enumerator
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+
+Simple test harness for Stub.
+Stub can't share the tests for \"real\" backends because it
+returns a somewhat contrived result set.
+
+
+> {-# LANGUAGE OverlappingInstances #-}
+
+> module Database.Stub.Test.Enumerator (runTest) where
+
+> import Database.Enumerator
+> import Database.Stub.Enumerator
+> -- import Database.Test.Performance as Perf
+> import System.Time  -- CalendarTime
+> import Test.MiniUnit
+> import Data.Int
+> import Control.Monad.Trans (liftIO)
+
+
+
+
+> runTest :: a -> [String] -> IO ()
+> runTest _ _ =
+>   withSession (connect (ConnParm "" "" ""))
+>     (runTestTT "Stub tests" (map runOneTest testList) >> return ())
+
+> runOneTest t = catchDB (t ()) reportRethrow
+
+> testList :: [() -> DBM mark Session ()]
+> testList =
+>   [ selectString, selectIterIO, selectFloatInt
+>   , selectStringNullInt, selectDatetime
+>   , selectCursor, selectExhaustCursor
+>   ]
+
+> selectTest iter expect = catchDB ( do
+>     actual <- doQuery (sql "") iter []
+>     liftIO $ assertEqual "" expect actual
+>   ) (\e -> return () )
+> selectTest' iter expect = catchDB ( do
+>     actual <- doQuery (prefetch 10 "") iter []
+>     liftIO $ assertEqual "" expect actual
+>   ) (\e -> return () )
+
+> selectString () = selectTest iter expect
+>   where
+>     -- To illustrate that the full signature is not necessary as long
+>     -- as some type information (e.g., (c1::String)) is provided --
+>     -- or enough context for the compiler to figure that out.
+>     -- iter :: (Monad m) => String -> IterAct m [String]
+>     -- iter :: String -> IterAct (DBM mark Session) [String]
+>     iter (c1::String) acc = result $ c1:acc
+>     expect = [ "boo", "boo", "boo" ]
+
+
+The following test illustrates doing IO in the iteratee itself.
+
+> -- monomorphism restriction strikes...
+> selectIterIO () = selectTest iter ([]::[String])
+>   where
+>     -- Here, it's better to avoid the signature and specify
+>     -- types of the arguments specifically so we do not have to
+>     -- figure out which exactly Monad we're operating in.
+>     -- We let the compiler figure out the right monad from
+>     -- the context (that is, from the Session)
+>     --iter :: String -> IterAct  (ReaderT Query SessionQuery) ()
+>     iter (c1::String) seed = do
+>       ct <- liftIO $ getClockTime
+>       liftIO $ putStr "<look: IO>"
+>       result seed
+
+
+> selectFloatInt () = selectTest' iter expect
+>   where
+>     iter :: (Monad m) => Double -> Int -> IterAct m [(Double, Int)]
+>     iter c1 c2 acc = result $ (c1, c2):acc
+>     expect = [ (1.1, 1), (1.1, 1), (1.1, 1) ]
+
+
+
+> selectStringNullInt () = selectTest' iter expect
+>   where
+>     iter :: (Monad m) =>
+>       String -> Maybe Int -> IterAct m [(String, Int)]
+>     iter c1 c2 acc = result $ (c1, ifNull c2 (-(1))):acc
+>     expect = [ ("boo", 1), ("boo", -1), ("boo", 1) ]
+
+
+> defDate = makeCalTime 19710701120101
+
+> selectDatetime () = selectTest iter expect
+>   where
+>     iter :: (Monad m) => CalendarTime -> IterAct m [CalendarTime]
+>     iter c1 acc = result $ c1:acc
+>     expect = [ defDate, defDate, defDate ]
+
+
+
+> selectCursor () = do
+>   let
+>     iter :: (Monad m) => Maybe Int -> IterAct m [Int]
+>     iter i acc = result $ (ifNull i 2):acc
+>   withCursor (sql "") iter [] $ \c -> do
+>     r <- cursorCurrent c
+>     liftIO $ assertEqual "selectCursor" [1] r
+>     doneBool <- cursorIsEOF c
+>     liftIO $ assertEqual "selectCursor" False doneBool
+>     --
+>     cursorNext c
+>     r <- cursorCurrent c
+>     liftIO $ assertEqual "selectCursor" [2, 1] r
+>     doneBool <- cursorIsEOF c
+>     liftIO $ assertEqual "selectCursor" False doneBool
+>     --
+>     cursorNext c
+>     r <- cursorCurrent c
+>     liftIO $ assertEqual "selectCursor" [1, 2, 1] r
+>     doneBool <- cursorIsEOF c
+>     liftIO $ assertEqual "selectCursor" False doneBool
+>     --
+>     cursorNext c
+>     r <- cursorCurrent c
+>     liftIO $ assertEqual "selectCursor" [1, 2, 1] r
+>     doneBool <- cursorIsEOF c
+>     liftIO $ assertEqual "selectCursor" True doneBool
+>     --
+>     return ()
+
+
+
+> selectExhaustCursor () = catchDB (do
+>     let
+>     -- Again, here we demonstrate the use of a local argument
+>     -- type annotation rather than the complete signature.
+>     -- Let the compiler figure out the monad and the seed type.
+>     --iter :: (Maybe m) => Maybe Int -> IterAct m [Int]
+>       iter (i::Maybe Int) acc = result $ (ifNull i (-(1))):acc
+>     withCursor (sql "") iter [] $ \c -> do
+>         cursorNext c
+>         cursorNext c
+>         cursorNext c
+>         cursorNext c
+>         liftIO $ assertFailure "selectExhaustCursor"
+>         return ()
+>     ) (\e -> return () )
+
+
+> makeCalTime :: Int64 -> CalendarTime
+> makeCalTime i =
+>   let
+>     year = (i `quot` 10000000000)
+>     month = ((abs i) `rem` 10000000000) `quot` 100000000
+>     day = ((abs i) `rem` 100000000) `quot` 1000000
+>     hour = ((abs i) `rem` 1000000) `quot` 10000
+>     minute = ((abs i) `rem` 10000) `quot` 100
+>     second = ((abs i) `rem` 100)
+>   in CalendarTime
+>     { ctYear = fromIntegral year
+>     , ctMonth = toEnum (fromIntegral month - 1)
+>     , ctDay = fromIntegral day
+>     , ctHour = fromIntegral hour
+>     , ctMin = fromIntegral minute
+>     , ctSec = fromIntegral second
+>     , ctPicosec = 0
+>     , ctWDay = Sunday
+>     , ctYDay = -1
+>     , ctTZName = "UTC"
+>     , ctTZ = 0
+>     , ctIsDST = False
+>     }
+
+ Database/Test/Enumerator.lhs view
@@ -0,0 +1,470 @@+
+|
+Module      :  Database.Test.Enumerator
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+
+Simple test harness. Demonstrates possible usage.
+
+Tests in this module are organised in groups of three/four functions:
+  sqlXXX
+  iterXXX
+  expectXXX
+  actionXXX
+
+These have to be tied together by a function which uses backend-specific
+functions and types. See the various backend-specific test modules for examples.
+
+
+> {-# LANGUAGE OverlappingInstances #-}
+
+> module Database.Test.Enumerator where
+
+> import Database.Enumerator
+> import Database.Util
+> import Data.Time
+> import System.Time
+> import Data.Int
+> import Control.Exception.MonadIO
+> import Control.Monad.Trans (liftIO)
+> --import Test.HUnit
+> import Test.MiniUnit
+
+
+> testTable = "takusen_test"
+
+> sqlDropDual = "drop table tdual"
+> sqlCreateDual = "create table tdual (dummy varchar(1) primary key)"
+> sqlInsertDual = "insert into tdual values ('X')"
+> sqlDropTest = "drop table " ++ testTable
+> sqlCreateTest = "create table " ++ testTable ++ " (id integer, v varchar(1000))"
+
+> sqlInsertTest1 = "insert into " ++ testTable ++ " (id, v) values (1, '2')"
+> sqlInsertTest2 = "insert into " ++ testTable ++ " (id, v) values (2, '2')"
+> sqlInsertTest3 = "insert into " ++ testTable ++ " (id, v) values (3, '3')"
+> sqlInsertTest4 = "insert into " ++ testTable ++ " (id, v) values (4, '4')"
+
+
+> reportError sql (DBFatal (ssc, sssc) e m) = do
+>   putStrLn ("FATAL: " ++ ssc ++ sssc ++ " - " ++ m)
+>   putStrLn ("  " ++ sql)
+> reportError sql (DBError (ssc, sssc) e m) = do
+>   putStrLn ("ERROR: " ++ ssc ++ sssc ++ " - " ++ m)
+>   putStrLn ("  " ++ sql)
+> reportError sql (DBUnexpectedNull r c) =
+>   putStrLn $ "Unexpected null in row " ++ (show r) ++ ", column " ++ (show c) ++ "."
+> reportError sql (DBNoData) = putStrLn "Fetch: no more data."
+
+-----------------------------------------------------------
+
+> class DBLiteralValue a where
+>   literalDate :: a -> Int64 -> String
+>   literalInt :: a -> Int -> String
+>   literalInt64 :: a -> Int64 -> String
+>   literalFloat :: a -> Float -> String
+>   literalDouble :: a -> Double -> String
+>   -- default methods
+>   literalInt _ i = show i
+>   literalInt64 _ i = show i
+>   literalFloat _ i = show i
+>   literalDouble _ i = show i
+
+
+> data SqliteFunctions = SqliteFunctions
+> data OracleFunctions = OracleFunctions
+> data PGSqlFunctions = PGSqlFunctions
+> data ODBCFunctions = ODBCFunctions
+
+> instance DBLiteralValue SqliteFunctions where
+>   literalDate _ i = dateSqlite i
+
+> instance DBLiteralValue OracleFunctions where
+>   literalDate _ i = dateOracle i
+
+> instance DBLiteralValue PGSqlFunctions where
+>   literalDate _ i = datePG i
+>   literalInt _ i = show i ++ "::int4"
+>   literalInt64 _ i = show i ++ "::int8"
+>   literalFloat _ i = show i ++ "::float4"
+>   literalDouble _ i = show i ++ "::float8"
+
+> instance DBLiteralValue ODBCFunctions where
+>   literalDate _ i = dateISO i
+
+
+
+> dateSqlite :: Int64 -> String
+> dateSqlite i = if i == 0 then "99999999999999" else show i
+
+> dateOracle :: Int64 -> String
+> dateOracle i
+>   | i == 0 = "to_date(null)"
+>   | i > 0  = "to_date('" ++ (zeroPad 14 i) ++ "', 'yyyymmddhh24miss')"
+>   | i < 0  = "to_date('" ++ (zeroPad 14 i) ++ "', 'syyyymmddhh24miss')"
+
+> dateISO :: Int64 -> String
+> dateISO i =
+>   let
+>     (year, month, day, hour, minute, second) = int64ToDateParts i
+>     zp = zeroPad
+>   in
+>   if i == 0 then "null"
+>   else zp 4 year ++ "-" ++ zp 2 month ++ "-" ++ zp 2 day
+>     ++ "T" ++ zp 2 hour ++ ":" ++ zp 2 minute ++ ":" ++ zp 2 second
+
+
+For postgres:
+0000-01-01 AD -> 0001-01-01 BC
+0000-12-31 AD -> 0001-12-31 BC
+0001-01-01 AD -> 0001-01-01 AD
+
+Using Doubles as storage (not sure about this?)
+4714-11-24 BC -> mindate
+5874897-12-31 AD -> maxdate
+Using 8-bytes ints:
+4713 BC -> 294276 AD
+
+Postgres only allows specification of -ve years by use of the AD/BC suffix.
+Sadly, this differs from the astronomical year number like so:
+astro: ...3,2,1,0,-1,-2,-3,...
+ad/bc: ...3AD,2AD,1AD,1BC,2BC,3BC,...
+
+i.e. 0 astro = 1BC, -1 astro = 2BC, etc.
+
+ISO8601 uses astronomical years, so we ought to be able to write
+-1000-12-25 (instead of 1001-01-01 BC), but Postgres won't parse this.
+
+So in datePG we want:
+int64  0000-01-01 -> 0001-01-01 AD
+int64  0001-01-01 -> 0001-01-01 AD
+int64 -0001-01-01 -> 0000-01-01 AD
+int64 -0002-01-01 -> 0003-01-01 BC
+int64 -4712-01-01 -> 4713-01-01 BC
+
+> datePG :: Int64 -> String
+> datePG i =
+>   let
+>     (year1, month, day, hour, minute, second) = int64ToDateParts i
+>     year = case () of
+>       _ | year1 == 0 -> 1
+>         | year1 < 0 -> abs (year1 - 1)
+>         | otherwise -> year1
+>     suffix = if year1 < 1 then " BC'" else " AD'"
+>     zp = zeroPad
+>   in
+>   if i == 0 then "null::timestamp"
+>   --else "timestamp with time zone '" ++ zp 4 year ++ "-" ++ zp 2 month ++ "-" ++ zp 2 day
+>   else "timestamp '" ++ zp 4 year ++ "-" ++ zp 2 month ++ "-" ++ zp 2 day
+>     ++ " " ++ zp 2 hour ++ ":" ++ zp 2 minute ++ ":" ++ zp 2 second ++ suffix
+
+
+
+
+> execDDL_ s = catchDB (execDDL s) reportRethrow
+> execDML_ s = execDDL_ s
+
+Use execDrop when the DDL is likely to raise an error.
+Note that PostgreSQL + ODBC seems to require you commit or rollback the DDL;
+if you don't then the next statement will fail with a 25P02
+("in failed SQL transaction")
+I guess that's a result of PostgreSQL's transactional DDL feature.
+
+> execDrop s = catchDB (withTransaction Serializable (execDDL s)) (\e -> return ())
+
+> makeFixture doDrop doDDL = flip catchDB (reportRethrowMsg "makeFixture: ") $ do
+>   doDrop sqlDropDual
+>   doDrop sqlDropTest
+>   doDDL sqlCreateDual
+>   beginTransaction ReadCommitted
+>   doDDL sqlInsertDual
+>   commit
+>   doDDL sqlCreateTest
+>   withTransaction Serialisable $ do
+>     doDDL sqlInsertTest1
+>     doDDL sqlInsertTest2
+>     doDDL sqlInsertTest3
+
+> destroyFixture execDDL_ = flip catchDB reportRethrow $ do
+>   execDDL_ sqlDropDual
+>   execDDL_ sqlDropTest
+>   catchDB commit (const (return ()))
+
+> selectTest query iter expect = do
+>   actual <- doQuery query iter []
+>   assertEqual query expect actual
+
+
+
+-----------------------------------------------------------
+
+This is used in a few tests...
+
+> sqlSingleValue = "select ? from tdual"
+
+> sqlNoRows = "select dummy from tdual where dummy = 'a' or dummy = '2' "
+> iterNoRows (c1::String) acc = result $ c1:acc
+> expectNoRows = []::[String]
+
+> sqlTermEarly = "select 'hello1' from tdual union select 'hello2' from tdual union select 'hello3' from tdual"
+> iterTermEarly c1 acc = if c1 == "hello2"
+>       then return (Left (c1:acc))
+>       else result (c1:acc)
+> expectTermEarly = ["hello2", "hello1"]
+
+> sqlFloatsAndInts fns = "select " ++ (literalDouble fns 4841.3403490431) ++ ", "
+>   ++ (literalInt fns (-22340234)) ++ " from tdual union select 33311.32332, 23789234 from tdual"
+> --iterFloatsAndInts :: (Monad m) => Double -> Int -> IterAct m [(Double, Int)]
+> iterFloatsAndInts (c1::Double) (c2::Int) acc = result $ (c1, c2):acc
+> expectFloatsAndInts :: [(Double, Int)]
+> expectFloatsAndInts = [ (33311.32332, 23789234) , (4841.3403490431, -22340234) ]
+
+> sqlNullString = "select 'hello1', 'hello2', null from tdual"
+> iterNullString :: (Monad m) => String -> String -> Maybe String
+>   -> IterAct m [(String, String, Maybe String)]
+> iterNullString c1 c2 c3 acc = result $ (c1, c2, c3):acc
+> expectNullString = [ ("hello1", "hello2", Nothing) ]
+
+> sqlEmptyString = "select 'hello1', 'hello2', '' from tdual /* Oracle always fails this test */"
+> iterEmptyString :: (Monad m) => String -> String -> Maybe String
+>                          -> IterAct m [(String, String, Maybe String)]
+> iterEmptyString c1 c2 c3 acc = result $ (c1, c2, c3):acc
+> expectEmptyString = [ ("hello1", "hello2", Just "") ]
+
+> sqlUnhandledNull = "select 'hello1', 'hello2', null from tdual"
+> iterUnhandledNull :: (Monad m) => String -> String -> UTCTime
+>                          -> IterAct m [(String, String, UTCTime)]
+> iterUnhandledNull c1 c2 c3 acc = result $ (c1, c2, c3):acc
+> expectUnhandledNull = []
+
+> sqlNullDate fns = "select 'hello1', 'hello2', " ++ (literalDate fns 0) ++ " from tdual"
+> iterNullDate :: (Monad m) => String -> String -> Maybe UTCTime
+>                          -> IterAct m [(String, String, UTCTime)]
+> iterNullDate c1 c2 c3 acc = result $ (c1, c2, ifNull c3 (int64ToUTCTime 10101000000)):acc
+> expectNullDate = [ ("hello1", "hello2", (int64ToUTCTime 10101000000)) ]
+
+> sqlDate fns = "select " ++ (literalDate fns 20041224235959) ++ " from tdual"
+> iterDate :: (Monad m) => UTCTime -> IterAct m [UTCTime]
+> iterDate c1 acc = result $ c1:acc
+> expectDate = [ (int64ToUTCTime 20041224235959) ]
+
+> iterCalDate :: (Monad m) => CalendarTime -> IterAct m [CalendarTime]
+> iterCalDate c1 acc = result $ c1:acc
+> expectCalDate = [ (int64ToCalTime 20041224235959) ]
+
+
+These are the Oracle date boundary cases.
+
+> sqlBoundaryDates fns =
+>             "select  " ++ (literalDate fns   99991231000000)  ++ " from tdual"
+>   ++ " union select  " ++ (literalDate fns      10101000000)  ++ " from tdual"
+>   ++ " union select  " ++ (literalDate fns    (-10101000000)) ++ " from tdual"
+>   ++ " union select  " ++ (literalDate fns (-47120101000000)) ++ " from tdual"
+>   ++ " order by 1 desc"
+> iterBoundaryDates :: (Monad m) => UTCTime -> IterAct m [UTCTime]
+> iterBoundaryDates c1 acc = result $ c1:acc
+> expectBoundaryDates =
+>   [ int64ToUTCTime (-47120101000000)
+>   , int64ToUTCTime    (-10101000000)
+>   , int64ToUTCTime      10101000000
+>   , int64ToUTCTime   99991231000000
+>   ]
+
+|Goal: exercise the  "happy path" throught cursor code
+i.e. open and fetch all rows, close after last row.
+
+> sqlCursor fns = "select " ++ literalInt fns 1 ++ " from tdual union select " ++ literalInt fns 2 ++ " from tdual"
+> iterCursor :: (Monad m) => Int -> IterAct m [Int]
+> iterCursor i acc = result $ i:acc
+> actionCursor query = do
+>   withCursor query iterCursor [] $ \c -> do
+>     doneBool <- cursorIsEOF c
+>     assertBool query (not doneBool)
+>     r <- cursorCurrent c
+>     assertEqual query [1] r
+>     --
+>     cursorNext c
+>     doneBool <- cursorIsEOF c
+>     assertBool query (not doneBool)
+>     r <- cursorCurrent c
+>     assertEqual query [2, 1] r
+>     --
+>     -- Now that the result-set is exhausted, cursorIsEOF returns True,
+>     -- and cursorCurrent returns the same value as the previous call to cursorCurrent.
+>     cursorNext c
+>     doneBool <- cursorIsEOF c
+>     assertBool query doneBool
+>     r <- cursorCurrent c
+>     assertEqual query [2, 1] r
+>     --
+>     -- What happens if try to advance again?
+>     -- We get a DBException: the DBNoData case.
+>     --cursorNext c
+>     doneBool <- cursorIsEOF c
+>     assertBool query doneBool
+>     r <- cursorCurrent c
+>     assertEqual query [2, 1] r
+>     --
+>     return ()
+
+|Goal: ensure exception raised when too many rows
+fetched from cursor.
+
+This test will raise an exception, as it tries to
+fetch too many rows from the cursor.
+The exception handler is coded as if we expect the
+exception i.e. it ignores it.
+The main action should never finish, so there's
+a failure assertion at the bottom, just in case
+the exception is not raised.
+
+> actionExhaustCursor query = catchDB (
+>     withCursor query iterCursor [] $ \c -> do
+>       cursorNext c
+>       cursorNext c
+>       cursorNext c
+>       cursorNext c
+>       assertFailure "selectExhaustCursor"
+>     ) (\e -> return () )
+
+> sqlBindString = "select ? from tdual union select ? from tdual order by 1"
+> iterBindString :: (Monad m) => String -> IterAct m [String]
+> iterBindString i acc = result $ i:acc
+> expectBindString = ["b1", "a2"]
+> actionBindString stmt bindVals = do
+>   withTransaction Serialisable $ do
+>   withPreparedStatement stmt $ \pstmt -> do
+>   withBoundStatement pstmt bindVals $ \bstmt -> do
+>     actual <- doQuery bstmt iterBindString []
+>     assertEqual sqlBindString expectBindString actual
+
+
+Each back-end has it's own idea of parameter placeholder syntax.
+We currently support ?-style as a lowest-common-denominator,
+and each back-end converts occurences of "?"
+to the back-end-specific style where required.
+If you use a back-end specific style, you can expect it to be passed
+through unmolested.
+  ?  : ODBC, MS Sql Server, Sqlite
+  :n : Oracle
+  $n : Postgres
+
+> sqlBindInt = "select ? from tdual union select ? from tdual order by 1"
+> iterBindInt :: (Monad m) => Int -> IterAct m [Int]
+> iterBindInt i acc = result $ i:acc
+> expectBindInt :: [Int]; expectBindInt = [2, 1]
+> actionBindInt stmt bindVals = do
+>   withTransaction Serialisable $ do
+>   withPreparedStatement stmt $ \pstmt -> do
+>   withBoundStatement pstmt bindVals $ \bstmt -> do
+>     actual <- doQuery bstmt iterBindInt []
+>     assertEqual sqlBindInt expectBindInt actual
+
+> sqlBindIntDoubleString = "select ?,?,? from tdual union select ?,?,? from tdual order by 1"
+> iterBindIntDoubleString :: (Monad m) => Int -> Double -> String -> IterAct m [(Int, Double, String)]
+> iterBindIntDoubleString i d s acc = result $ (i, d, s):acc
+> expectBindIntDoubleString :: [(Int, Double, String)]
+> expectBindIntDoubleString = [(3, 4.4, "row 2"), (1, 2.2, "row 1")]
+> actionBindIntDoubleString stmt = do
+>   withTransaction Serialisable $ do
+>     actual <- doQuery stmt iterBindIntDoubleString []
+>     assertEqual sqlBindIntDoubleString expectBindIntDoubleString actual
+
+> sqlBindDate = sqlSingleValue
+> iterBindDate :: (Monad m) => UTCTime -> IterAct m [UTCTime]
+> iterBindDate c1 acc = result $ c1:acc
+> expectBindDate = [ (int64ToUTCTime 20041224235959) ]
+> actionBindDate stmt = do
+>   withTransaction Serialisable $ do
+>     actual <- doQuery stmt iterBindDate []
+>     assertEqual sqlBindDate expectBindDate actual
+
+> sqlBindBoundaryDates =
+>             "select ? from tdual"
+>   ++ " union select ? from tdual"
+>   ++ " union select ? from tdual"
+>   ++ " union select ? from tdual"
+>   ++ " order by 1 desc"
+> actionBindBoundaryDates stmt = do
+>   withTransaction Serialisable $ do
+>     actual <- doQuery stmt iterBindDate []
+>     assertEqual sqlBindBoundaryDates expectBoundaryDates actual
+
+
+> sqlBoundStmtDML = "insert into " ++ testTable ++ " (id, v) values (?, ?)"
+> actionBoundStmtDML stmt = do
+>   withPreparedStatement stmt $ \pstmt -> do
+>     -- do it twice, to check that prepared stmt can be reused.
+>     -- Note that with bound statements, the query (or command)
+>     -- already been executed, so it's too late to begin the transaction.
+>     beginTransaction Serialisable
+>     withBoundStatement pstmt [bindP (100::Int), bindP "100"] $ \bstmt -> do
+>       count <- execDML bstmt
+>       rollback
+>       assertEqual sqlBoundStmtDML 1 count
+>     beginTransaction Serialisable
+>     withBoundStatement pstmt [bindP (100::Int), bindP "100"] $ \bstmt -> do
+>       count <- execDML bstmt
+>       rollback
+>       assertEqual sqlBoundStmtDML 1 count
+
+
+
+With 'MyTree' we test the ability to send and receive arbtrary Show-able
+values as Strings i.e. we create our own datatype for the test.
+
+> data MyTree a = Leaf a | Branch [MyTree a] deriving (Eq, Show, Read)
+
+> sqlPolymorphicFetch = sqlSingleValue
+> iterPolymorphicFetch :: (Monad m) => MyTree String -> IterAct m (MyTree String)
+> iterPolymorphicFetch v _ = result' v
+> expectPolymorphicFetch = Branch [Leaf "a", Leaf "b", Branch [Leaf "c", Leaf "d"], Leaf "e"]
+> actionPolymorphicFetch stmt = do
+>   actual <- doQuery stmt iterPolymorphicFetch (Leaf "")
+>   assertEqual sqlPolymorphicFetch expectPolymorphicFetch actual
+
+> sqlPolymorphicFetchNull = "select '' from tdual"
+> iterPolymorphicFetchNull :: (Monad m) => Maybe (MyTree String) -> IterAct m (Maybe (MyTree String))
+> iterPolymorphicFetchNull v _ = result' v
+> expectPolymorphicFetchNull :: Maybe (MyTree String)
+> expectPolymorphicFetchNull = Nothing
+> actionPolymorphicFetchNull stmt = do
+>   actual <- doQuery stmt iterPolymorphicFetchNull Nothing
+>   assertEqual sqlPolymorphicFetchNull Nothing actual
+
+> sqlRebind = sqlSingleValue
+> iterRebind (i::Int) acc = result $ i:acc
+> expectRebind1 :: [Int]; expectRebind1 = [1]
+> expectRebind2 :: [Int]; expectRebind2 = [2]
+> actionRebind stmt bindVal1 bindVal2 = do
+>   withPreparedStatement stmt $ \pstmt -> do
+>     withBoundStatement pstmt bindVal1 $ \bstmt -> do
+>       actual <- doQuery bstmt iterRebind []
+>       assertEqual sqlRebind expectRebind1 actual
+>     withBoundStatement pstmt bindVal2 $ \bstmt -> do
+>       actual <- doQuery bstmt iterRebind []
+>       assertEqual sqlRebind expectRebind2 actual
+
+> sqlExceptionRollback = "select count(*) from " ++ testTable
+> iterExceptionRollback (i::Int) acc = result $ i:acc
+> actionExceptionRollback insertStmt selectStmt = do
+>   catchDB (
+>     withTransaction Serialisable $ do
+>       execDML insertStmt
+>       throwDB DBNoData
+>     ) (\e -> return () )
+>   count <- doQuery selectStmt iterExceptionRollback []
+>   assertEqual sqlExceptionRollback [3] count
+
+> sqlIterateeMatchesResultSet = "select ?,?,? from tdual"
+> --iterMatchesResultSet :: (Monad m) => Int -> Double -> String -> IterAct m [(Int, Double, String)]
+> --iterMatchesResultSet i d s acc = result $ (i, d, s):acc
+> iterMatchesResultSet :: (Monad m) => Int -> Double -> String -> String -> IterAct m [(Int, Double, String, String)]
+> iterMatchesResultSet i d s s2 acc = result $ (i, d, s, s2):acc
+> actionIterateeMatchesResultSet stmt = do
+>   catchDB ( do
+>       actual <- doQuery stmt iterMatchesResultSet []
+>       assertFailure "actionIterateeMatchesResultSet"
+>     ) (\e -> return () )
+ Database/Test/MultiConnect.lhs view
@@ -0,0 +1,35 @@+
+|
+Module      :  Database.Test.MultiConnect
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+
+Tests Database.Enumerator code in the context of multiple
+database connections to different DBMS products.
+We should add tests to shift data between databases, too.
+
+
+> {-# LANGUAGE OverlappingInstances #-}
+
+> module Database.Test.MultiConnect (runTest) where
+
+> import qualified Database.Sqlite.Enumerator as Sqlite
+> import qualified Database.PostgreSQL.Enumerator as PG
+> import Database.Sqlite.Test.Enumerator as SqlTest
+> import Database.PostgreSQL.Test.Enumerator as PGTest
+> import Database.Test.Performance as Perf
+> import Database.Enumerator
+> import System.Environment (getArgs)
+
+
+> runTest :: Perf.ShouldRunTests -> [String] -> IO ()
+> runTest runPerf args = catchDB ( do
+>     let [ user, pswd, dbname ] = args
+>     withSession (PG.connect user pswd dbname) $ \sessPG -> do
+>     withSession (Sqlite.connect user pswd dbname) $ \sessSql -> do
+>       SqlTest.runTest runPerf args
+>       PGTest.runTest runPerf args
+>   ) basicDBExceptionReporter
+ Database/Test/Performance.lhs view
@@ -0,0 +1,99 @@+
+|
+Module      :  Database.Test.Performance
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+
+Performance tests. Currently just tests large result sets.
+
+
+> {-# LANGUAGE OverlappingInstances #-}
+
+> module Database.Test.Performance where
+
+> import Database.Enumerator
+> import Database.Util
+> import System.Environment (getArgs)
+> import Control.Monad
+> import System.Time
+> import Test.MiniUnit
+> import Control.Monad.Reader
+
+> data ShouldRunTests = RunTests | Don'tRunTests deriving (Show, Eq)
+
+> timedCursor stmt limit rows = do
+>   withCursor stmt (rowCounter rows) 0 $ \c -> do
+>     ct1 <- liftIO getClockTime
+>     replicateM_ rows (cursorNext c)
+>     ct2 <- liftIO getClockTime
+>     let diffCt = diffClockTimes ct2 ct1
+>     let limitDiff = TimeDiff 0 0 0 0 0 limit 0
+>     print_ $ "timedCursor: " ++ timeDiffToString diffCt
+>     assertBool ("timedCursor: time " ++ (timeDiffToString diffCt) ++ " (limit " ++ (timeDiffToString limitDiff) ++ ")")
+>       (diffCt < limitDiff)
+
+
+> timedSelect stmt limit rows = do
+>   ct1 <- liftIO getClockTime
+>   r <- doQuery stmt (rowCounter rows) 0
+>   ct2 <- liftIO getClockTime
+>   let diffCt = diffClockTimes ct2 ct1
+>   -- assume it must complete within limit seconds
+>   let limitDiff = TimeDiff 0 0 0 0 0 limit 0
+>   print_ $ "timedSelect: " ++ timeDiffToString diffCt
+>   assertBool ("timedSelect: time " ++ (timeDiffToString diffCt) ++ " (limit " ++ (timeDiffToString limitDiff) ++ ")")
+>     (diffCt < limitDiff)
+>   assertEqual ("timedSelect: rows " ++ (show r)) rows r
+
+
+|This counter takes the maximum number of rows to fetch as its first argument,
+so don't forget to curry it when using it as an iteratee function.
+We also try to ensure that it is strict in the counter;
+we don't want thousands or millions of unevaluated '+' thunks sitting
+on the stack.
+
+> rowCounter :: (Monad m) => Int -> Int -> IterAct m Int
+> rowCounter n _ i = result' (i+1)
+>   --if i >= n then return (Left $! i) else return (Right $! (1 + i))
+>   --if i >= n then return (Left i) else return (Right (1 + i))
+
+
+2 ^ 16 = 65536
+2 ^ 20 = 1048576
+
+Cartesian product. Each instance of the subquery multiplies
+the total number of rows by 2, so the number of rows
+is 2 ^ (count of subquery instances).
+You start to notice the pause around 2^13,
+and 2^16 blows out the standard 1M stack
+if you use the lazy version of result. Bummer.
+
+> sqlRows2Power17 :: String
+> sqlRows2Power17 = 
+>   "select 1 from"
+>   ++ "  ( select 1 x from tdual union select 0 from tdual) t1"
+>   ++ ", ( select 2 x from tdual union select 0 from tdual) t2"
+>   ++ ", ( select 3 x from tdual union select 0 from tdual) t3"
+>   ++ ", ( select 4 x from tdual union select 0 from tdual) t4"
+>   ++ ", ( select 5 x from tdual union select 0 from tdual) t5"
+>   ++ ", ( select 6 x from tdual union select 0 from tdual) t6"
+>   ++ ", ( select 7 x from tdual union select 0 from tdual) t7"
+>   ++ ", ( select 8 x from tdual union select 0 from tdual) t8"
+>   ++ ", ( select 9 x from tdual union select 0 from tdual) t9"
+>   ++ ", ( select 10 x from tdual union select 0 from tdual) t10"
+>   ++ ", ( select 11 x from tdual union select 0 from tdual) t11"
+>   ++ ", ( select 12 x from tdual union select 0 from tdual) t12"
+>   ++ ", ( select 13 x from tdual union select 0 from tdual) t13"
+>   ++ ", ( select 14 x from tdual union select 0 from tdual) t14"
+>   ++ ", ( select 15 x from tdual union select 0 from tdual) t15"
+>   ++ ", ( select 16 x from tdual union select 0 from tdual) t16"
+>   ++ ", ( select 17 x from tdual union select 0 from tdual) t17"
+
+> sqlRows2Power20 :: String
+> sqlRows2Power20 = sqlRows2Power17
+>   ++ ", ( select 18 x from tdual union select 0 from tdual) t18"
+>   ++ ", ( select 19 x from tdual union select 0 from tdual) t19"
+>   ++ ", ( select 20 x from tdual union select 0 from tdual) t20"
+ Database/Test/Util.lhs view
@@ -0,0 +1,129 @@+> {-# LANGUAGE CPP #-}
+
+> module Database.Test.Util where
+
+> import Database.Util
+> import Test.MiniUnit
+> import Data.Int
+> import Data.Char
+
+
+> runTest :: a -> [String] -> IO ()
+> runTest _ _ = do
+>   counts <- runTestTT "Util module tests" testlist
+>   return ()
+
+> testlist = 
+>   [ testSubstr
+>   , testWordsBy
+>   , testInt64ToDatePartsMinDate
+>   , testInt64ToDatePartsMaxDate
+>   , testUtcTimeToInt64MinDate
+>   , testUtcTimeToInt64MaxDate
+>   , testCalTimeToInt64MinDate
+>   , testCalTimeToInt64MaxDate
+>   , testInt64ToCalTimeMinDate
+>   , testInt64ToCalTimeMaxDate
+>   , testPGDatetimeToUTCTimeMinDate
+>   , testPGDatetimeToUTCTimeMaxDate
+>   , testPGDatetimeToUTCTimeBCBoundary
+>   , testPGDatetimeToUTCTimeBCBoundary2
+>   , testUTCTimeToPGDatetimeMinDate
+>   , testUTCTimeToPGDatetimeMaxDate
+>   ]
+
+> testSubstr = do
+>   assertEqual "substr - 1" "a" (substr 1 1 "abc")
+>   assertEqual "substr - 2" "b" (substr 2 1 "abc")
+>   assertEqual "substr - 3" "c" (substr 3 1 "abc")
+>   assertEqual "substr - 4" "bc" (substr 2 2 "abc")
+>   assertEqual "substr - 5" "ab" (substr 1 2 "abc")
+>   assertEqual "substr - 6" "abc" (substr 1 4 "abc")
+>   assertEqual "substr -76" "" (substr 4 4 "abc")
+
+> testWordsBy = do
+>   assertEqual "wordsBy - 1" [] (wordsBy isDigit "")
+>   assertEqual "wordsBy - 2" [] (wordsBy isDigit " --,")
+>   assertEqual "wordsBy - 2.5" ["5"] (wordsBy isDigit "5")
+>   assertEqual "wordsBy - 2.75" ["5"] (wordsBy isDigit "5 ")
+>   assertEqual "wordsBy - 3" ["5"] (wordsBy isDigit "5 --,")
+>   assertEqual "wordsBy - 4" ["6"] (wordsBy isDigit " --,6")
+>   assertEqual "wordsBy - 5" ["7"] (wordsBy isDigit " --7, ")
+>   assertEqual "wordsBy - 6" ["100", "12", "67", "25"] (wordsBy isDigit "100-12,67--, 25")
+
+
+-4712 (4713BC?) is a very common minimum date among DBMS implementations.
+Maximum varies, but is often 5874897 AD.
+
+ghc-6.4.1 needs this, because it only has Show instances for
+up to 5-tuples.
+
+#if __GLASGOW_HASKELL__ <= 604
+> instance (Show a, Show b, Show c, Show d, Show e, Show f)
+>   => Show (a,b,c,d,e,f) where
+>   show (a,b,c,d,e,f) =
+>     "(" ++ show a
+>     ++ "," ++ show a
+>     ++ "," ++ show b
+>     ++ "," ++ show c
+>     ++ "," ++ show d
+>     ++ "," ++ show e
+>     ++ "," ++ show f
+>     ++ ")"
+#endif
+
+> testInt64ToDatePartsMinDate = do
+>   let expect :: (Int64,Int64,Int64,Int64,Int64,Int64); expect = (-4712,1,1,0,0,0)
+>   assertEqual "testInt64ToDatePartsMinDate" expect (int64ToDateParts (-47120101000000))
+
+> testInt64ToDatePartsMaxDate = do
+>   let expect :: (Int64,Int64,Int64,Int64,Int64,Int64); expect = (999999,12,31,23,59,59)
+>   assertEqual "testInt64ToDatePartsMaxDate" expect (int64ToDateParts (9999991231235959))
+
+> testUtcTimeToInt64MinDate = do
+>   let expect :: Int64; expect = (-47120101000000)
+>   assertEqual "testUtcTimeToInt64MinDate" expect (utcTimeToInt64 (mkUTCTime (-4712) 1 1 0 0 0))
+
+> testUtcTimeToInt64MaxDate = do
+>   let expect :: Int64; expect = (9999991231235959)
+>   assertEqual "testUtcTimeToInt64MaxDate" expect (utcTimeToInt64 (mkUTCTime 999999 12 31 23 59 59))
+
+> testCalTimeToInt64MinDate = do
+>   let expect :: Int64; expect = (-47120101000000)
+>   assertEqual "testCalTimeToInt64MinDate" expect (calTimeToInt64 (mkCalTime (-4712) 1 1 0 0 0))
+
+> testCalTimeToInt64MaxDate = do
+>   let expect :: Int64; expect = (9999991231235959)
+>   assertEqual "testCalTimeToInt64MaxDate" expect (calTimeToInt64 (mkCalTime 999999 12 31 23 59 59))
+
+> testInt64ToCalTimeMinDate = do
+>   let expect = mkCalTime (-4712) 1 1 0 0 0
+>   assertEqual "testInt64ToCalTimeMinDate" expect (int64ToCalTime (-47120101000000))
+
+> testInt64ToCalTimeMaxDate = do
+>   let expect = mkCalTime 999999 12 31 23 59 59
+>   assertEqual "testInt64ToCalTimeMaxDate" expect (int64ToCalTime 9999991231235959)
+
+> testPGDatetimeToUTCTimeMinDate = do
+>   let expect = mkUTCTime (-4712) 1 1 0 0 0
+>   assertEqual "testPGDatetimeToUTCTimeMinDate" expect (pgDatetimetoUTCTime "4713-01-01 00:00:00 BC")
+
+> testPGDatetimeToUTCTimeMaxDate = do
+>   let expect = mkUTCTime 999999 1 1 0 0 0
+>   assertEqual "testPGDatetimeToUTCTimeMaxDate" expect (pgDatetimetoUTCTime "999999-01-01 00:00:00+00")
+
+> testPGDatetimeToUTCTimeBCBoundary = do
+>   let expect = mkUTCTime 0 1 1 0 0 0
+>   assertEqual "testPGDatetimeToUTCTimeBCBoundary" expect (pgDatetimetoUTCTime "0001-01-01 00:00:00 BC")
+
+> testPGDatetimeToUTCTimeBCBoundary2 = do
+>   let expect = mkUTCTime 0 12 31 0 0 0
+>   assertEqual "testPGDatetimeToUTCTimeBCBoundary2" expect (pgDatetimetoUTCTime "0001-12-31 00:00:00 BC")
+
+> testUTCTimeToPGDatetimeMinDate = do
+>   let expect = "4713-01-01T00:00:00.000000+00 BC"
+>   assertEqual "testUTCTimeToPGDatetimeMinDate" expect (utcTimeToPGDatetime (mkUTCTime (-4712) 1 1 0 0 0))
+
+> testUTCTimeToPGDatetimeMaxDate = do
+>   let expect = "999999-01-01T00:00:00.300001+00 AD"
+>   assertEqual "testUTCTimeToPGDatetimeMaxDate" expect (utcTimeToPGDatetime (mkUTCTime 999999 1 1 0 0 0.300001))
Database/Util.lhs view
@@ -10,10 +10,7 @@ Utility functions. Mostly used in database back-ends, and tests.
 
 
-> {-# OPTIONS -fglasgow-exts #-}
-> {-# OPTIONS -fallow-overlapping-instances #-}
-> {-# OPTIONS -fallow-undecidable-instances #-}
-
+> {-# LANGUAGE TypeSynonymInstances #-}
 > {-# LANGUAGE FlexibleInstances #-}
 > {-# LANGUAGE OverlappingInstances #-}
 > {-# LANGUAGE UndecidableInstances #-}
@@ -27,6 +24,10 @@ > import Data.List
 > import Data.Char
 > import Data.Time
+> import Data.Word (Word8)
+> import Foreign.Ptr (Ptr, castPtr)
+> import Foreign.Marshal.Array (peekArray)
+> import Numeric (showHex)
 > import Text.Printf
 
 
@@ -142,8 +143,8 @@ > wordsBy pred s = skipNonMatch pred s
 
 2 states:
-skipNonMatch is for when we are looking for the start of our next word
-consumeMatch is for when we are currently scanning a word
+ - skipNonMatch is for when we are looking for the start of our next word
+ - scanWord is for when we are currently scanning a word
 
 > skipNonMatch :: (Char -> Bool) -> String -> [String] 
 > skipNonMatch pred "" = []
@@ -260,3 +261,18 @@ >     ++ ":" ++ zeroPad 2 minute
 >     ++ ":" ++ secs
 >     ++ "+00" ++ suffix
+
+
+> printArrayContents :: Int -> Ptr Word8 -> IO ()
+> printArrayContents sz ptr = do
+>   putStrLn ("printBufferContents: sz = " ++ show sz)
+>   l <- peekArray sz ptr
+>   let
+>     toHex :: Word8 -> String;
+>     toHex i = (if i < 16 then "0" else "") ++ showHex i ""
+>   --let h :: [String]; h = map toHex l
+>   putStrLn (concat (intersperse " " (map toHex l)))
+>   let
+>     toChar :: Word8 -> String
+>     toChar i = if 31 < i && i < 127 then [chr (fromIntegral i)] else " "
+>   putStrLn (concat (intersperse "  " (map toChar l)))
+ Foreign/C/Test/UTF8.hs view
@@ -0,0 +1,138 @@+
+-- |
+-- Module      :  Foreign.C.Test.UTF8
+-- Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+-- License     :  BSD-style
+-- Maintainer  :  alistair@abayley.org
+-- Stability   :  experimental
+-- Portability :  non-portable
+-- 
+-- UTF8 decoder and encoder tests.
+
+
+module Foreign.C.Test.UTF8 where
+
+import Prelude hiding (catch)
+import Control.Exception.Extensible
+import Data.Char
+import Foreign.C.String
+import Foreign.C.UTF8
+import Foreign.Marshal.Array
+import Foreign.Ptr
+import Test.MiniUnit
+import qualified Test.QuickCheck as QC
+import Data.Word (Word8)
+
+
+runTest :: a -> [String] -> IO ()
+runTest _ args = runTestTT "UTF8" mkTestList >> return ()
+
+--mkTestList :: Test
+--mkTestList = TestList (map TestCase testlist)
+mkTestList = testlist
+
+testlist :: [IO ()]
+testlist = 
+  [ testUTF8RoundTrip
+  , testUTF8StringLenRoundTrip
+  , quickCheckUTF8RoundTrip
+  , testFromUTF8Failure5Bytes
+  , testFromUTF8Failure6Bytes
+  -- , testLargeFromUTF8
+  -- , testLargeFromUTF8Len
+  ]
+
+
+instance QC.Arbitrary Char where
+  arbitrary = QC.choose (chr 1, chr 0x10FFFF)
+  coarbitrary = undefined
+
+prop_roundtrip s = s == fromUTF8 (toUTF8 s)
+quickCheckUTF8RoundTrip = QC.test prop_roundtrip
+
+testUTF8RoundTrip = do
+  utf8RoundTrip "1ByteLow"   0x000001 [0x01]
+  utf8RoundTrip "1ByteHigh"  0x00007F [0x7F]
+  utf8RoundTrip "2BytesLow"  0x000080 [0xC2, 0x80]
+  utf8RoundTrip "2BytesHigh" 0x0007FF [0xDF, 0xBF]
+  utf8RoundTrip "3BytesLow"  0x000800 [0xE0, 0xA0, 0x80]
+  utf8RoundTrip "3BytesHigh" 0x00FFFF [0xEF, 0xBF, 0xBF]
+  utf8RoundTrip "4BytesLow"  0x010000 [0xF0, 0x90, 0x80, 0x80]
+  -- chr 0x10FFFF is the largest code-point Haskell currently allows
+  utf8RoundTrip "4BytesHigh" 0x10FFFF [0xF4, 0x8F, 0xBF, 0xBF]
+
+utf8RoundTrip :: String -> Int -> [Word8] -> IO ()
+utf8RoundTrip msg unicode utf8 = do
+  assertEqual ("testToUTF8-" ++ msg) utf8 (toUTF8 [chr unicode])
+  assertEqual ("testFromUTF8-" ++ msg) [chr unicode] (fromUTF8 utf8)
+  withUTF8String [chr unicode] $ \cstr -> do
+    w8 <- peekArray0 0 (castPtr cstr)
+    assertEqual ("testToUTF8Ptr-" ++ msg) utf8 w8
+  withCString (map (chr . fromIntegral) utf8) $ \cstr -> do
+    s <- peekUTF8String cstr
+    assertEqual ("testFromUTF8Ptr-" ++ msg) [chr unicode] s
+
+testUTF8StringLenRoundTrip = do
+  utf8StringLenRoundTrip "1ByteLow"   [0x000001, 0x000001] [0x01, 0x01]
+  utf8StringLenRoundTrip "2BytesLow"  [0x000080, 0x00007F] [0xC2, 0x80, 0x7F]
+  utf8StringLenRoundTrip "3BytesLow"  [0x000800, 0x000001] [0xE0, 0xA0, 0x80, 0x01]
+  utf8StringLenRoundTrip "4BytesLow"  [0x010000, 0x00007F] [0xF0, 0x90, 0x80, 0x80, 0x7F]
+  utf8StringLenRoundTrip "4BytesHigh" [0x10FFFF, 0x00007F] [0xF4, 0x8F, 0xBF, 0xBF, 0x01]
+
+utf8StringLenRoundTrip :: String -> [Int] -> [Word8] -> IO ()
+utf8StringLenRoundTrip msg codepoints utf8 = do
+  let unicode = map chr codepoints
+  let expect = take (length unicode - 1) unicode
+  -- convert our unicode code-points (Haskell String)
+  -- into a UTF8 CStringLen.
+  -- Pass this back to peekUTF8StringLen to convert back into Haskell String.
+  -- Chop off the last char - make sure it's only one byte.
+  withUTF8StringLen unicode $ \(cstr, clen) -> do
+    assertEqual ("testUTF8StringLenRoundTrip-" ++ msg) (length utf8) clen
+    s <- peekUTF8StringLen (cstr, clen - 1)
+    assertEqual ("testUTF8StringLenRoundTrip-" ++ msg) expect s
+
+
+
+--testUTF8StringLenRoundTrip = do
+
+testFromUTF8Failure5Bytes = do
+  let utf8 = [0xF8, 0x80, 0x80, 0x80, 0x80]
+  let handler :: ErrorCall -> IO ()
+      handler (ErrorCall msg) = assertEqual "testFromUTF8Failure5Bytes" "fromUTF8: illegal UTF-8 character 248" msg
+  catch (do
+    assertEqual "testFromUTF8Failure5Bytes" [chr 0x10FFFF] (fromUTF8 utf8)
+    assertBool "testFromUTF8Failure5Bytes: no error raised" False
+    ) handler
+
+testFromUTF8Failure6Bytes = do
+  let utf8 = [0xFD, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF]
+  let handler :: ErrorCall -> IO ()
+      handler (ErrorCall msg) = assertEqual "testFromUTF8Failure6Bytes" "fromUTF8: illegal UTF-8 character 253" msg
+  catch (do
+    assertEqual "testFromUTF8Failure6Bytes" [chr 0x10FFFF] (fromUTF8 utf8)
+    assertBool "testFromUTF8Failure6Bytes: no error raised" False
+    ) handler
+{-
+testLargeFromUTF8 = do
+  let sz = 1000000
+  withCString (take sz (repeat 'a')) $ \cstr -> do
+    s <- peekUTF8String cstr
+    assertEqual "testLargeFromUTF8" sz (length s)
+    s <- peekUTF8StringB cstr
+    assertEqual "testLargeFromUTF8B" sz (length s)
+    s <- peekUTF8StringLen (cstr, sz)
+    assertEqual "testLargeFromUTF8Len" sz (length s)
+    s <- peekUTF8StringLenB (cstr, sz)
+    assertEqual "testLargeFromUTF8LenB" sz (length s)
+-}
+
+{-
+testLargeFromUTF8Len = do
+  let sz = 1000000
+  withCStringLen (take sz (repeat 'a')) $ \(cstr, clen) -> do
+    putStrLn "testLargeFromUTF8Len: call peekUTF8StringLen"
+    s <- peekUTF8StringLen (cstr, clen)
+    putStrLn "testLargeFromUTF8Len: assert length"
+    assertEqual "testLargeFromUTF8Len" sz (length s)
+-}
Foreign/C/UTF8.hs view
@@ -1,5 +1,4 @@ 
-{-# OPTIONS_GHC -cpp #-}
 {-# LANGUAGE CPP #-}
 
 -- |
@@ -21,7 +20,7 @@ -- well, you have the original String, so...
 
 
--- This module has been reasonablt optimised. You can check GHC's
+-- This module has been reasonably optimised. You can check GHC's
 -- simplifier output (for unboxing, mainly) with this:
 --   ghc -O2 -c UTF8.hs -ddump-simpl > simpl.txt
 
@@ -251,12 +250,12 @@ fromUTF8Ptr0 :: Ptr Word8 -> IO String
 fromUTF8Ptr0 p = do
   len <- lengthArray0 nullByte p
-  --fromUTF8PtrUnboxed (len-1) p ""
   fromUTF8Ptr (len-1) p ""
 
 -- | The bytes parameter should be len-1
--- i.e. if the CString has length 2, then you should pass
--- bytes=1.
+-- i.e. if the CString has length 2, then you should pass bytes=1.
+-- That's because we add bytes to the Ptr p to get the offset
+-- for each byte; byte 1 is at p+0, byte 2 is at p+1, etc.
 fromUTF8Ptr :: Int -> Ptr Word8 -> String -> IO String
 fromUTF8Ptr bytes p acc
   | bytes `seq` p `seq` acc `seq` False = undefined
+ Main.lhs view
@@ -0,0 +1,70 @@+
+|
+Module      :  Main
+Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+License     :  BSD-style
+Maintainer  :  oleg@pobox.com, alistair@abayley.org
+Stability   :  experimental
+Portability :  non-portable
+ 
+Simple driver module, mainly for testing.
+Imports test modules and runs test suites.
+ 
+This project is now hosted at haskell.org:
+ 
+@darcs get <http://darcs.haskell.org/takusen>@
+ 
+Invoke main like this (assuming the compiled executable is called @takusen@):
+ 
+ > takusen stub noperf
+ > takusen sqlite noperf "" "" dbname
+ > takusen oracle noperf "" "" dbname  -- no username, so os-authenticated
+ > takusen mssql noperf user paswd dbname
+
+
+> module Main (main) where
+
+
+> import Database.Sqlite.Test.Enumerator as Sqlite
+> import Database.Oracle.Test.Enumerator as Oracle
+> --import Database.Test.MultiConnect as Multi
+> import Database.ODBC.Test.Enumerator as ODBC
+> import Database.Stub.Test.Enumerator as Stub
+> --import Database.MSSqlServer.Test.Enumerator as MSSql
+> import Database.PostgreSQL.Test.Enumerator as PGSql
+> import System.Environment (getArgs)
+> import Database.Test.Performance as Perf
+> import Database.Test.Util as Util
+> import Foreign.C.Test.UTF8 as UTF8
+
+
+> main :: IO ()
+> main = do
+>   args <- getArgs
+>   if (length args < 2)
+>     then showUsage
+>     else do
+>       let (impl:perf:as) = args
+>       doTests impl perf as
+
+> showUsage = do
+>   putStrLn "usage: takusen backend {no}perf user pswd database"
+
+> doTests impl perf args = do
+>   let runPerf = if perf == "perf" then Perf.RunTests else Perf.Don'tRunTests
+>   case lookup impl backendTests of
+>     Nothing -> putStrLn $ "No backend for " ++ impl ++ "."
+>     Just test -> test runPerf args
+
+> backendTests :: [(String, Perf.ShouldRunTests -> [String] -> IO ())]
+> backendTests =
+>   [ ("sqlite", Sqlite.runTest)
+>   , ("pgsql", PGSql.runTest)
+>   , ("odbc", ODBC.runTest)
+>   --, ("mssql", MSSql.runTest)
+>   , ("oracle", Oracle.runTest)
+>   --, ("multi", Multi.runTest)
+>   , ("stub", Stub.runTest)
+>   , ("utf8", UTF8.runTest)
+>   , ("util", Util.runTest)
+>   ]
+ README.txt view
@@ -0,0 +1,177 @@+Installing
+----------
+Prerequisites: GHC >= 6.6, Cabal >= 1.6, filepath
+
+Note that on Windows you will require cabal-1.6.0.2 for ghc-6.6,
+as there is a bug in cabal-1.6.0.1 which breaks it on ghc-6.6 on Windows.
+cabal-1.6.0.1, which is bundled with ghc-6.10, is fine for ghc-6.8 and later.
+
+(It was possible to use Takusen with GHC-6.4; see notes in separate section
+below.)
+
+To run or build Setup.hs you will need filepath installed.
+This is only needed by Setup.hs, and is not required by Takusen itself.
+filepath comes with ghc-6.8 and later, but is a separate download and
+install for ghc-6.6.
+
+Ensure that the database libraries for any particular database you plan
+to use are in your path e.g. ensure that %ORACLE_HOME%\bin is in your path.
+If the library is not in your path, then the buildtools won't be found,
+and the configure will fail.
+
+The installation uses Cabal configurations. Each of the backends is
+enabled by a flag, and the flags are all False by default. If you want
+to enable a particular backend, you must enable its flag with -f
+e.g. Setup configure -fodbc -foracle -fpostgres -fsqlite
+
+Typical build, after unzipping the distribution archive (Takusen-?.?.gz):
+  $ ghc --make Setup
+  $ Setup configure -fodbc -foracle -fpostgres -fsqlite
+  $ Setup build
+  $ Setup install
+
+Typical build, using darcs to get latest code:
+  $ mkdir takusen
+  $ cd takusen
+  $ darcs get http://darcs.haskell.org/takusen
+  $ ghc --make Setup
+  $ Setup configure -fodbc -foracle -fpostgres -fsqlite
+  $ Setup build
+  $ Setup install
+
+It may be that you also need to specify library or include dirs in the
+setup configure step. For example, the Oracle Instant Client on Linux
+puts header files in a different location from normal i.e. not under
+$ORACLE_HOME. In that case you will have to use --extra-include-dirs=...,
+and possibly --extra-lib-dirs=..., in the configure step.
+
+Setup under ghc-6.6 expects the sqlite.h header file to be in the same
+location as sqlite3.exe. You can get sqlite3.h from the sqlite source bundle,
+and rename to sqlite.h.
+  
+
+
+Using i.e. Writing data access code
+-----------------------------------
+There are extensive instructions and examples in the Haddock docs
+for module Database.Enumerator:
+ http://darcs.haskell.org/takusen/doc/html/Database-Enumerator.html
+
+This should give you most, if not all, of the information you need to
+create a program that uses Takusen.
+
+Here's a little hello-world test case that uses Sqlite:
+
+{-# OPTIONS -fglasgow-exts #-}
+{-# OPTIONS -fallow-overlapping-instances #-}
+module Main where
+import Database.Sqlite.Enumerator
+import Control.Monad.Trans (liftIO)
+main = flip catchDB reportRethrow $
+  withSession (connect "sqlite_db") (do
+    let iter (s::String) (_::String) = result s
+    result <- doQuery (sql "select 'Hello world.'") iter ""
+    liftIO (putStrLn result)
+    )
+
+If this is Main.hs, then
+  $ ghc --make Main -o hello
+should build a "hello" executable.
+
+
+
+Paths, GHCi & runhaskell
+------------------------
+Just as with ensuring that your path is correctly set when building Takusen,
+you must also ensure it is correctly set when building your programs.
+If it is not correct, then you are likely to see linker errors.
+
+The Cabal build script (Setup.hs) looks for various executables
+on your path, in order to configure, or validate the configuration.
+For example:
+ - the Oracle configuration checks that sqlplus is available before continuing
+ - The PostgreSQL configuration uses the pg_config program to get the library
+   and include directory locations.
+
+If you install a new back-end, you will need to re-run the installation
+process to be able to use it.
+
+
+
+PostgreSQL gotchas on Windows
+-----------------------------
+The PostgreSQL client library is called libpq.dll on Windows, rather than
+the more typical pq.dll. This is fine when using ghc to compile, as gnu ld
+is able to figure out that this is the library to use when you pass it -lpq,
+but ghci is not quite so slick, and it fails to load the library.
+
+There is any easy workaround, which is to copy libpq.dll and rename it to
+pq.dll. If you do this, then you should be able to use ghci with PostgreSQL
+without problems. Don't forget to ensure that PostgreSQL's bin is in your path.
+
+In the past I've had problems with older versions of PostgreSQL and
+ghc-6.4.1. Specifically, the call to PQprepare would segfault.
+This occured with C programs (i.e. no Haskell) compiled with the gcc
+and ld that came with ghc-6.4.1. If ld (version 2.15.91) was replaced
+with an older one (2.13.91) from MSYS then the test program worked.
+
+With PostgreSQL 8.1.5.1 and ghc-6.6 (gcc 3.4.5 (mingw special)
+and ld 2.15.94) this problem seems to have vanished.
+
+
+
+Oracle gotchas on Windows
+-------------------------
+Some users have reported linker errors because their Oracle bin contains
+hsbase.dll, which is an Oracle library related to Heterogenous Services.
+This DLL overrides GHC's HSbase.dll, and therefore causes linker errors.
+
+If you can control your Oracle client installation then either
+ - don't choose Heterogenous Services when you install,
+   or re-run the installer and remove it, or
+ - rename hsbase.dll in Oracle bin.
+
+
+
+GHC-6.4 and Takusen
+-------------------
+It was possible to use Takusen with GHC-6.4.
+We no longer test this configuration, so you may need to do some work
+it you want to go down this path.
+
+You will need to install Data.Time, which is quite a chore on Windows
+because of the dependencies. You will also need MSYS installed in order
+to be able to run autoreconf, so get that out of the way first.
+
+The summary for Windows is:
+
+darcs get --partial http://www-users.cs.york.ac.uk/~ndm/filepath/
+(or download and unzip the prepared distribution)
+normal cabal configure, build, install
+
+darcs get --partial http://www.cse.unsw.edu.au/~dons/code/fps
+(or download and unzip the prepared distribution)
+normal cabal configure, build, install
+
+darcs get http://darcs.haskell.org/packages/Win32
+Edit Win32.cabal, add fps to build-depends.
+normal cabal configure, build, install
+
+darcs get http://semantic.org/TimeLib/TimeLib
+There are two packages here: time and fixed. Ignore time.
+Go into fixed and do cabal configure, build, install
+
+darcs get http://darcs.haskell.org/packages/time
+Edit time.cabal, add fixed and Win32 to build-depends.
+create Setup.hs:
+  import Distribution.Simple
+  main = defaultMainWithHooks defaultUserHooks
+From MSYS shell, not Windows cmd.exe:
+  $ autoreconf
+  $ ghc --make Setup
+  $ Setup configure
+  $ Setup build
+  $ Setup install
+
+And finally, build Takusen with the normal cabal configure,
+build, install.
Setup.hs view
@@ -1,11 +1,14 @@ #!/usr/bin/env runhaskell 
 
+-- setup configure -fodbc -foracle -fpostgres -fsqlite
+
 import Distribution.PackageDescription
   ( PackageDescription(..), Library(..), BuildInfo(..), HookedBuildInfo
-  , emptyHookedBuildInfo, writeHookedBuildInfo, emptyBuildInfo
+  , emptyHookedBuildInfo, emptyBuildInfo
   )
-import Distribution.Package (Dependency(..))
-import Distribution.Simple.Setup ( ConfigFlags(..) )
+import Distribution.PackageDescription.Parse ( writeHookedBuildInfo ) 
+import Distribution.Package (Dependency(..), PackageName(..))
+import Distribution.Simple.Setup ( ConfigFlags(..), BuildFlags(.. ), fromFlag)
 import Distribution.Simple
   ( defaultMainWithHooks, autoconfUserHooks, UserHooks(..), Args )
 import Distribution.Simple.Program (findProgramOnPath, simpleProgram, Program(..))
@@ -16,8 +19,9 @@ import qualified System.Info (os)
 import System.Directory (canonicalizePath, removeFile)
 import System.Environment (getEnv)
-import System.FilePath (combine, dropFileName, FilePath)
+import System.FilePath (combine, dropFileName, FilePath, pathSeparators)
 import System.IO.Error (try)
+import Data.List (isInfixOf)
 import Data.Maybe (fromJust)
 import Data.Monoid (mconcat)
 
@@ -43,6 +47,7 @@ 
 -}
 
+
 main = defaultMainWithHooks autoconfUserHooks
   { preConf=preConf, postConf=postConf
   , hookedPrograms = [pgConfigProgram, odbcConfigProgram, sqlite3Program, sqlplusProgram]
@@ -54,15 +59,15 @@       return emptyHookedBuildInfo
     postConf :: Args -> ConfigFlags -> PackageDescription -> LocalBuildInfo -> IO ()
     postConf args flags pkgdesc localbuildinfo = do
-      let verbose = (configVerbose flags)
+      let verbose = fromFlag (configVerbosity flags)
       let lbi = libBuildInfo (fromJust (library pkgdesc))
       let buildtools = buildTools lbi
       sqliteBI <- configSqlite3 verbose buildtools 
       pgBI <- configPG verbose buildtools
       oraBI <- configOracle verbose buildtools
       odbcBI <- configOdbc verbose buildtools
-      let bi = mconcat [sqliteBI, pgBI, oraBI, odbcBI, Just lbi]
-      writeHookedBuildInfo "Takusen.buildinfo" (bi, [])
+      let bi = mconcat [sqliteBI, pgBI, oraBI, odbcBI, lbi]
+      writeHookedBuildInfo "Takusen.buildinfo" (Just bi, [])
 
 
 -- ODBCConf.exe - MDAC install actions - command line?
@@ -76,35 +81,48 @@ 
 isWindows = System.Info.os == "mingw32" || System.Info.os == "windows"
 
+-- ghc-6.6.1 can't cope with a trailing slash or backslash on the end
+-- of the include dir path, so we strip it off.
+-- Not sure why this is; there might be something else causing it to fail
+-- which has gone unnoticed.
+stripTrailingSep :: String -> String
+stripTrailingSep p
+  = reverse
+  . (\s -> if [head s] `isInfixOf` pathSeparators then drop 1 s else s)
+  . reverse
+  $ p
+
 makeConfig path libDir includeDir = do
   libDirs <- canonicalizePath (combine path libDir)
   includeDirs <- canonicalizePath (combine path includeDir)
   return
-    (Just emptyBuildInfo
-      { extraLibDirs = [libDirs], includeDirs = [includeDirs] })
+    (emptyBuildInfo
+      { extraLibDirs = [stripTrailingSep libDirs], includeDirs = [stripTrailingSep includeDirs] })
 
 maybeGetEnv :: String -> IO (Maybe String)
 maybeGetEnv env = do
   catch ( getEnv env >>= return . Just ) ( const (return Nothing) )
 
 -- Check that the program is in the buildtools.
--- If it is, then run the action (which should return Maybe BuildInfo).
--- If not, return Nothing.
-guardProg :: Program -> [Dependency] -> IO (Maybe BuildInfo) -> IO (Maybe BuildInfo)
+-- If it is, then run the action (which should return BuildInfo).
+-- If not, return emptyBuildInfo.
+-- Cabal populates the buildtools list depending on which flags
+-- have been passed to "setup configure".
+guardProg :: Program -> [Dependency] -> IO BuildInfo -> IO BuildInfo
 guardProg prog tools action = do
-  if prog `isElem` tools then action else return Nothing
+  if prog `isElem` tools then action else return emptyBuildInfo
   where
     isElem program buildtools = or (map (match program) buildtools)
-    match program (Dependency tool _) = (programName program) == tool
+    match program (Dependency (PackageName tool) _) = (programName program) == tool
 
 -- Run the first action to give a Maybe FilePath.
 -- If this is Nothing then emit a warning about library not found.
 -- Otherwise, run the second action over the FilePath.
-guardPath :: (IO (Maybe FilePath)) -> String -> Verbosity -> (FilePath -> IO (Maybe BuildInfo)) -> IO (Maybe BuildInfo)
+guardPath :: (IO (Maybe FilePath)) -> String -> Verbosity -> (FilePath -> IO BuildInfo) -> IO BuildInfo
 guardPath pathAction libName verbose resAction = do
   mb <- pathAction
   case mb of
-    Nothing -> warn verbose ("No " ++libName++ " library found") >> return Nothing
+    Nothing -> warn verbose ("No " ++libName++ " library found") >> return emptyBuildInfo
     Just path -> info verbose ("Using " ++libName++ ": " ++ path) >> resAction path
 
 -- From the Oracle 10g manual:
@@ -133,15 +151,15 @@     if isWindows
       then guardPath (programFindLocation sqlite3Program verbose) "Sqlite3" verbose $ \path -> do
         makeConfig (dropFileName path) "" ""
-      else return Nothing
+      else return emptyBuildInfo
 
 configPG verbose buildtools = do
-  guardProg sqlplusProgram buildtools $ do
+  guardProg pgConfigProgram buildtools $ do
   guardPath (programFindLocation pgConfigProgram verbose) "PostgreSQL" verbose $ \pq_config_path -> do
   lib_dirs <- rawSystemStdout verbose pq_config_path ["--libdir"]
   inc_dirs <- rawSystemStdout verbose pq_config_path ["--includedir"]
   inc_dirs_server <- rawSystemStdout verbose pq_config_path ["--includedir-server"]
-  return ( Just emptyBuildInfo
+  return (emptyBuildInfo
     { extraLibDirs = words lib_dirs
     , includeDirs = words inc_dirs ++ words inc_dirs_server
     })
@@ -154,7 +172,7 @@ 
 configOdbc verbose buildtools | isWindows = do
   info verbose "Using ODBC: <on Windows => lib already in PATH>"
-  return Nothing
+  return emptyBuildInfo
 configOdbc verbose buildtools = do
   --info verbose "Using odbc: <on *nix => assume lib already in PATH>"
-  return Nothing
+  return emptyBuildInfo
Takusen.cabal view
@@ -1,5 +1,12 @@+-- setup configure -fodbc -foracle -fpostgres -fsqlite
+-- setup build
+-- setup install
+--
+-- setup configure -fbuildtests
+-- setup build
+-- setup install
 Name:           Takusen
-Version:        0.8.3
+Version:        0.8.4
 License:        BSD3
 License-file:   LICENSE
 Author:         Alistair Bayley, Oleg Kiselyov
@@ -10,7 +17,7 @@ Package-url:    http://darcs.haskell.org/takusen
 Category:       Database
 Build-type:     Custom
-Cabal-Version:  >= 1.4
+Cabal-Version:  >= 1.6
 Synopsis:       Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.
 Description:   
     Takusen is a DBMS access library. Like HSQL and HDBC, we support
@@ -48,26 +55,68 @@ Flag sqlite
   Description: SQLite3 backend
   Default:     False
+Flag buildtests
+  Description: Build test executables
+  Default:     False
 
+
+Executable takusen_tests
+  If !flag(buildtests)
+    Buildable: False
+  else
+    -- If we want to build test exe, then it needs Takusen installed.
+    Build-Depends:  Takusen
+  Main-Is: Main.lhs
+  Build-Depends:  base, mtl, time, QuickCheck
+  -- ghc-6.6 has System.Time in base.
+  -- Later versions has it in a separate package.
+  if impl(ghc >= 6.8)
+    Build-Depends:  old-time
+  Extensions: CPP DeriveDataTypeable ScopedTypeVariables
+  if impl(ghc>=6.9)
+    cpp-options: -DUSE_NEW_EXCEPTIONS
+    build-depends: base>=4&&<5
+  else
+    build-depends: base<4
+
+Executable miniunit_tests
+  If !flag(buildtests)
+    Buildable: False
+  Main-Is: Test/Main.hs
+  Build-Depends:  base, mtl
+  Extensions: CPP DeriveDataTypeable ScopedTypeVariables
+  if impl(ghc>=6.9)
+    cpp-options: -DUSE_NEW_EXCEPTIONS
+    build-depends: base>=4&&<5
+  else
+    build-depends: base<4
+
+
 Library
 
+  If flag(buildtests)
+    Buildable: False
+
   Exposed-modules:
         Database.Enumerator
       , Database.Util
-      , Database.Stub.Enumerator
+      --, Database.Stub.Enumerator
       , Control.Exception.MonadIO
+      , Control.Exception.Extensible
       , Foreign.C.UTF8
 
   If flag(odbc)
     Exposed-modules:
         Database.ODBC.Enumerator
       , Database.ODBC.OdbcFunctions
-    Build-Tools: odbcconf
     If os(windows)
       extra-libraries: odbc32
       ld-options: --enable-stdcall-fixup
     Else
-      extra-libraries: odbc
+      If os(darwin)
+        extra-libraries: iodbc
+      Else
+        extra-libraries: odbc
 
   If flag(oracle)
     Exposed-modules:
@@ -98,9 +147,26 @@       Build-Tools: sqlite3
     Extra-Libraries: sqlite3
 
-  Build-Depends:  base, mtl, time, old-time
-  -- Database.Enumerator uses CPP to make a deriving clause palatable for Haddock.
-  Extensions: CPP
+  Build-Depends:  base, mtl, time
+  -- ghc-6.6 has System.Time in base.
+  -- Later versions has it in a separate package.
+  if impl(ghc >= 6.8)
+    Build-Depends:  old-time
+  -- Many modules use CPP to switch between new and old exceptions.
+  -- DeriveDataTypeable is because we can't switch it on/off with #define;
+  -- for ghc-6.6 it is rendered as -fglasgow-exts anyway.
+  Extensions: CPP DeriveDataTypeable
+  -- We need the USE_NEW_EXCEPTIONS flag as this is used in
+  -- Control.Exception.Extensible is choose between defining our own
+  -- extensible exceptions, or re-exporting what's in base-4.
+  if impl(ghc>=6.9)
+    cpp-options: -DUSE_NEW_EXCEPTIONS
+    build-depends: base>=4&&<5
+  else
+    build-depends: base<4
+  if impl(ghc >= 6.10)
+    -- doesn't work with Data.Time on older ghcs, due to some missing header file
+    Ghc-Options: -O2
   Other-modules: 
       Database.InternalEnumerator
       -- We don't expose the Test modules; the only reason to do so would be so Haddock
@@ -108,4 +174,3 @@       -- and for that they'd have to be in Exposed-modules.
       -- Modules in Other-modules are passed to Haddock with --hide=<module-name>.
   Ghc-Prof-Options: -prof -auto-all
-  --Ghc-Options: -O2  -- doesn't work with Data.Time, due to some missing header file
+ Test/Main.hs view
@@ -0,0 +1,7 @@+
+module Main where
+
+import Test.MiniUnitTest
+
+main :: IO ()
+main = tests
+ Test/MiniUnit.hs view
@@ -0,0 +1,178 @@+
+-- |
+-- Module      :  Test.MiniUnit
+-- Copyright   :  (c) 2004 Oleg Kiselyov, Alistair Bayley
+-- License     :  BSD-style
+-- Maintainer  :  oleg@pobox.com, alistair@abayley.org
+-- Stability   :  experimental
+-- Portability :  portable
+--
+-- This is just a simple one-module unit test framework, with the same
+-- API as "Test.HUnit" (albeit with a lot of stuff missing).
+-- We use it because it works in 'Control.Exception.MonadIO.CaughtMonadIO'
+-- instead of IO
+-- (and also because I couldn't convert "Test.HUnit"
+-- to use 'Control.Exception.MonadIO.CaughtMonadIO').
+
+{-# LANGUAGE CPP #-}
+
+module Test.MiniUnit
+  (
+  -- ** Primary API
+    runTestTT, assertFailure, assertBool, assertString, assertEqual
+  -- ** Exposed for self-testing only; see "Test.MiniUnitTest"
+  , TestResult(..), throwUserError, runSingleTest, reportResults
+  )
+where
+
+import Control.Exception.MonadIO
+import Control.Exception.Extensible
+import Control.Monad
+import Control.Monad.Trans (liftIO)
+import System.IO.Error (ioeGetErrorString)
+import System.IO
+import Data.List
+import Data.IORef
+
+
+data TestResult = TestSuccess | TestFailure String | TestException String
+  deriving (Show, Eq)
+
+-- We'll use HUnit's trick of throwing an IOError when an assertion fails.
+-- This will terminate the test case, obviously, but we catch the exception
+-- and record that it haa failed so that we can continue with other
+-- test cases.
+
+-- Unlike HUnit, we catch all exceptions; any that are not thrown by
+-- failed assertions are recorded as test errors (as opposed to test failures),
+-- and the testing continues...
+
+-- When an assertion fails, we throw an IOException with a special
+-- text prefix, which the exception handler will detect.
+assertFailure :: CaughtMonadIO m => String -> m ()
+assertFailure msg = throwUserError (exceptionPrefix ++ msg)
+
+exceptionPrefix = "MiniUnit:"
+hugsPrefix  = "IO Error: User error\nReason: "
+nhc98Prefix = "I/O error (user-defined), call to function `userError':\n  "
+ghcPrefix = ""  -- We don't use this; it's just documentation...
+
+dropPrefix p s = if isPrefixOf p s then drop (length p) s else s
+trimCompilerPrefixes = dropPrefix hugsPrefix . dropPrefix nhc98Prefix
+
+throwUserError :: CaughtMonadIO m => String -> m ()
+throwUserError msg = liftIO (throwIO (userError msg))
+
+runSingleTest :: CaughtMonadIO m => m () -> m TestResult
+runSingleTest action = do
+  let
+    iohandler :: CaughtMonadIO m =>IOException -> m TestResult
+    iohandler e = 
+          let errText = trimCompilerPrefixes (ioeGetErrorString e) in
+          if isPrefixOf exceptionPrefix errText
+            then return (TestFailure (dropPrefix exceptionPrefix errText))
+            else return (TestException (show e))
+    errhandler :: CaughtMonadIO m => SomeException -> m TestResult
+    errhandler e = return (TestException (show e))
+  (action >> return TestSuccess)
+    `gcatch` iohandler
+    `gcatch` errhandler
+
+-- Predicates for list filtering
+isSuccess TestSuccess = True
+isSuccess _ = False
+isFailure (TestFailure _) = True
+isFailure _ = False
+isError (TestException _) = True
+isError _ = False
+
+-- Make function composition look more like Unix pipes.
+-- This first definition requires a Point-Free Style.
+-- I prefer the PFS, as you can use it in (for example) predicate
+-- functions passed as arguments (see filter example below).
+infixl 9 |>
+(|>) = flip (.)
+
+-- This second definition affords a more pointed style...
+-- We can use this operator to inject an argument into a pipe
+-- defined using |>; it has lower precedence, so will bind last.
+-- e.g. ... = mylist |>> zip [1..] |> filter (snd |> pred) |> map show |> concat
+infixl 8 |>>
+(|>>) = flip ($)
+
+--reportFilter pred = zip [1..] |> filter (snd |> pred) |> map testReporter |> concat
+
+testReporter (n, TestSuccess) = ""
+testReporter (n, TestException s) = "Test " ++ show n ++ " failed with exception:\n" ++ s ++ "\n"
+testReporter (n, TestFailure s) = "Test " ++ show n ++ " failed with message:\n" ++ s ++ "\n"
+
+reportResults list =
+  let
+    s = list |>> filter isSuccess |> length
+    e = list |>> filter isError   |> length
+    f = list |>> filter isFailure |> length
+  in "Test cases: " ++ show (length list)
+  ++ "  Failures: " ++ show f
+  ++ "  Errors: " ++ show e
+  -- ++ reportFilter isFailure list
+  -- ++ reportFilter isError list
+
+-- 2 defns for same result; which is better?
+--contains pred = filter pred |> null |> not
+contains p l = maybe False (const True) (find p l)
+
+-- | Return 0 if everything is rosy,
+-- 1 if there were assertion failures (but no exceptions),
+-- 2 if there were any exceptions.
+-- You could use this return code as the return code from
+-- your program, if you're driving from the command line.
+runTestTT :: CaughtMonadIO m => String -> [m ()] -> m Int
+runTestTT desc list = do
+  liftIO (putStrLn "")
+  when (desc /= "") (liftIO (putStr (desc ++ " - ")))
+  liftIO (putStrLn ("Test case count: " ++ show (length list)))
+  r <- mapM (\(n, t) -> liftIO (putStr "." >> hFlush stdout) >> runSingleTestTT n t) (zip [1..] list)
+  liftIO (putStrLn "")
+  liftIO (putStrLn (reportResults r))
+  if contains isError r
+    then return 2
+    else if contains isFailure r
+      then return 1
+      else return 0
+
+-- Could use this instead of runSingleTest - it will output
+-- failures and exceptions as they occur, rather than all
+-- at the end.
+runSingleTestTT :: CaughtMonadIO m => Int -> m () -> m TestResult
+runSingleTestTT n test = do
+  r <- runSingleTest test
+  case r of
+    TestSuccess -> return r
+    TestFailure _ -> liftIO (putStrLn ('\n':(testReporter (n ,r)))) >> return r
+    TestException _ -> liftIO (putStrLn ('\n':(testReporter (n, r)))) >> return r
+
+---------------------------------------------
+-- That's the basic framework; now for some sugar...
+-- ... stolen straight from Dean Herrington's HUnit code.
+-- Shall we steal his infix operators, too?
+
+assertBool :: CaughtMonadIO m => String -> Bool -> m ()
+assertBool msg b = unless b (assertFailure msg)
+
+assertString :: CaughtMonadIO m => String -> m ()
+assertString s = unless (null s) (assertFailure s)
+
+assertEqual :: (Eq a, Show a, CaughtMonadIO m) =>
+     String  -- ^ message preface
+  -> a  -- ^ expected
+  -> a  -- ^ actual
+  -> m ()
+assertEqual preface expected actual = do
+  let
+    msg =
+      (if null preface then "" else preface ++ "\n")
+      ++ "expect: " ++ show expected ++ "\nactual: " ++ show actual
+  unless (actual == expected) (assertFailure msg)
+
+
+--p @? msg = assertBool msg p
+ Test/MiniUnitTest.hs view
@@ -0,0 +1,64 @@+
+{-# LANGUAGE NoMonomorphismRestriction #-}
+ 
+module Test.MiniUnitTest where
+
+import Test.MiniUnit
+import Data.IORef
+import Control.Exception.MonadIO
+import Control.Monad.Trans (liftIO)
+
+
+tests = do
+  print_ "MiniUnit tests..."
+  test__assertFailure
+  test__runSingleTestSuccess
+  test__runSingleTestFailure
+  test__runSingleTestException
+  test__reportResults
+  print_ "Testing runTestTT; ignore following test output."
+  test__runTestTT
+  print_ "MiniUnit tests done."
+
+print_ s = liftIO (putStrLn s)
+
+test__assertFailure = catch
+  (assertFailure "test__assertFailure"
+    >> error "test__assertFailure: failed: exception not thrown.")
+  (\e -> print_ "test__assertFailure OK")
+
+reportResult name result = do
+  case result of
+    TestSuccess -> print_ (name ++ " OK")
+    TestFailure _ -> print_ (name ++ " failed")
+    TestException _ -> print_ (name ++ " exception")
+
+test__runSingleTestSuccess =
+  runSingleTest (return ())
+  >>= reportResult "test__runSingleTestSuccess"
+
+test__runSingleTestFailure =
+  runSingleTest (assertFailure "test__runSingleTestFailure")
+  >>= reportResult "test__runSingleTestFailure"
+
+test__runSingleTestException = do
+  result <- runSingleTest (throwUserError "boo")
+  case result of
+    TestSuccess -> print_ "test__runSingleTestException failed"
+    TestFailure _ -> print_ "test__runSingleTestException failed!"
+    TestException _ -> print_ "test__runSingleTestException OK"
+
+test__reportResults = do
+  results <- mapM runSingleTest
+    [assertFailure "test__runSingleTest", return (), throwUserError "boo"]
+  let expect = "Test cases: 3  Failures: 1  Errors: 1"
+  if reportResults results == expect
+    then print_ "test__reportResults OK"
+    else print_ "test__reportResults failed!"
+
+
+test__runTestTT = do
+  r <- runTestTT "MiniUnitTest" [assertFailure "test__runSingleTest", return (), throwUserError "boo"]
+  return ()
+
+----
+ doc/html/Control-Exception-MonadIO.html view
@@ -0,0 +1,239 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Control.Exception.MonadIO</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Control.Exception.MonadIO</FONT
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Documentation</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> MonadIO m =&gt; <A NAME="t%3ACaughtMonadIO"
+></A
+><B
+>CaughtMonadIO</B
+> m  <SPAN CLASS="keyword"
+>where</SPAN
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+>Methods</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Agcatch"
+></A
+><B
+>gcatch</B
+> :: m a -&gt; (Exception -&gt; m a) -&gt; m a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgcatchJust"
+></A
+><B
+>gcatchJust</B
+> :: (Exception -&gt; Maybe b) -&gt; m a -&gt; (b -&gt; m a) -&gt; m a</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:CaughtMonadIO')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:CaughtMonadIO" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> IO</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> si =&gt; <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark si)</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> (ReaderT a m)</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Agtry"
+></A
+><B
+>gtry</B
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; m b -&gt; m (Either Exception b)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgtryJust"
+></A
+><B
+>gtryJust</B
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; (Exception -&gt; Maybe b) -&gt; m b1 -&gt; m (Either b b1)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Agbracket"
+></A
+><B
+>gbracket</B
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; m t -&gt; (t -&gt; m a) -&gt; (t -&gt; m b) -&gt; m b</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Agfinally"
+></A
+><B
+>gfinally</B
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; m t -&gt; m a -&gt; m t</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/Database-Enumerator.html view
@@ -0,0 +1,5722 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Database.Enumerator</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Database.Enumerator</FONT
+></TD
+><TD ALIGN="right"
+><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="infohead"
+>Portability</TD
+><TD CLASS="infoval"
+>non-portable</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Stability</TD
+><TD CLASS="infoval"
+>experimental</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Maintainer</TD
+><TD CLASS="infoval"
+>oleg@pobox.com, alistair@abayley.org</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+><B
+>Contents</B
+></TD
+></TR
+><TR
+><TD
+><DL
+><DT
+><A HREF="#1"
+>Usage
+</A
+></DT
+><DD
+><DL
+><DT
+><A HREF="#2"
+>Iteratee Functions
+</A
+></DT
+><DT
+><A HREF="#3"
+>result and result'
+</A
+></DT
+><DT
+><A HREF="#4"
+>Rank-2 types, ($), and the monomorphism restriction
+</A
+></DT
+><DT
+><A HREF="#5"
+>Bind Parameters
+</A
+></DT
+><DT
+><A HREF="#6"
+>Multiple (and nested) Result Sets
+</A
+></DT
+></DL
+></DD
+><DT
+><A HREF="#7"
+>Sessions and Transactions
+</A
+></DT
+><DT
+><A HREF="#8"
+>Exceptions and handlers
+</A
+></DT
+><DT
+><A HREF="#9"
+>Preparing and Binding
+</A
+></DT
+><DT
+><A HREF="#10"
+>Iteratees and Cursors
+</A
+></DT
+><DT
+><A HREF="#11"
+>Utilities
+</A
+></DT
+></DL
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Description</TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>Abstract database interface, providing a left-fold enumerator
+ and cursor operations.
+</P
+><P
+>There is a stub: <A HREF="Database-Stub-Enumerator.html"
+>Database.Stub.Enumerator</A
+>.
+ This lets you run the test cases without having a working DBMS installation.
+ This isn't so valuable now, because it's dead easy to install Sqlite,
+ but it's still there if you want to try it.
+</P
+><P
+>Additional reading:
+</P
+><UL
+><LI
+> <A HREF="http://pobox.com/~oleg/ftp/Haskell/misc.html#fold-stream"
+>http://pobox.com/~oleg/ftp/Haskell/misc.html#fold-stream</A
+>
+</LI
+><LI
+> <A HREF="http://pobox.com/~oleg/ftp/papers/LL3-collections-enumerators.txt"
+>http://pobox.com/~oleg/ftp/papers/LL3-collections-enumerators.txt</A
+>
+</LI
+><LI
+> <A HREF="http://www.eros-os.org/pipermail/e-lang/2004-March/009643.html"
+>http://www.eros-os.org/pipermail/e-lang/2004-March/009643.html</A
+>
+</LI
+></UL
+><P
+>Note that there are a few functions that are exported from each DBMS-specific
+ implementation which are exposed to the API user, and which are part of
+ the Takusen API, but are not (necessarily) in this module.
+ They include:
+</P
+><UL
+><LI
+> <TT
+>connect</TT
+> (obviously DBMS specific)
+</LI
+><LI
+><PRE
+>prepareQuery, prepareLargeQuery, prepareCommand, sql, sqlbind, prefetch, cmdbind</PRE
+></LI
+></UL
+><P
+>These functions will typically have the same names and intentions,
+ but their specific types and usage may differ between DBMS.
+</P
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Synopsis</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ADBM"
+>DBM</A
+> mark sess a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="#t%3AISession"
+>ISession</A
+> sess </TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AConnectA"
+>ConnectA</A
+> sess</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AwithSession"
+>withSession</A
+> :: (Typeable a, <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess) =&gt; <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> sess -&gt; (<SPAN CLASS="keyword"
+>forall</SPAN
+> mark . <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AwithContinuedSession"
+>withContinuedSession</A
+> :: (Typeable a, <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess) =&gt; <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> sess -&gt; (<SPAN CLASS="keyword"
+>forall</SPAN
+> mark . <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a) -&gt; IO (a, <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> sess)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Acommit"
+>commit</A
+> :: <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> s =&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Arollback"
+>rollback</A
+> :: <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> s =&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbeginTransaction"
+>beginTransaction</A
+> :: (MonadReader s (ReaderT s IO), <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> s) =&gt; <A HREF="Database-Enumerator.html#t%3AIsolationLevel"
+>IsolationLevel</A
+> -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AwithTransaction"
+>withTransaction</A
+> :: <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> s =&gt; <A HREF="Database-Enumerator.html#t%3AIsolationLevel"
+>IsolationLevel</A
+> -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s a -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AIsolationLevel"
+>IsolationLevel</A
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+>= <A HREF="#v%3AReadUncommitted"
+>ReadUncommitted</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3AReadCommitted"
+>ReadCommitted</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ARepeatableRead"
+>RepeatableRead</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ASerialisable"
+>Serialisable</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ASerializable"
+>Serializable</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AexecDDL"
+>execDDL</A
+> :: <A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> stmt s =&gt; stmt -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AexecDML"
+>execDML</A
+> :: <A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> stmt s =&gt; stmt -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Ainquire"
+>inquire</A
+> :: <A HREF="Database-Enumerator.html#t%3AEnvInquiry"
+>EnvInquiry</A
+> key s result =&gt; key -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s result</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ADBException"
+>DBException</A
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+>= <A HREF="#v%3ADBError"
+>DBError</A
+> <A HREF="Database-Enumerator.html#t%3ASqlState"
+>SqlState</A
+> Int String</TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ADBFatal"
+>DBFatal</A
+> <A HREF="Database-Enumerator.html#t%3ASqlState"
+>SqlState</A
+> Int String</TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ADBUnexpectedNull"
+>DBUnexpectedNull</A
+> <A HREF="Database-Enumerator.html#t%3ARowNum"
+>RowNum</A
+> <A HREF="Database-Enumerator.html#t%3AColNum"
+>ColNum</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ADBNoData"
+>DBNoData</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AformatDBException"
+>formatDBException</A
+> :: <A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbasicDBExceptionReporter"
+>basicDBExceptionReporter</A
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; <A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; m ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AreportRethrow"
+>reportRethrow</A
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; <A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; m a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AreportRethrowMsg"
+>reportRethrowMsg</A
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; String -&gt; <A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; m a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcatchDB"
+>catchDB</A
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; m a -&gt; (<A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; m a) -&gt; m a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcatchDBError"
+>catchDBError</A
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; Int -&gt; m a -&gt; (<A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; m a) -&gt; m a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AignoreDBError"
+>ignoreDBError</A
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; Int -&gt; m a -&gt; m a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AthrowDB"
+>throwDB</A
+> :: <A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AColNum"
+>ColNum</A
+> = Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ARowNum"
+>RowNum</A
+> = Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlState"
+>SqlState</A
+> = (<A HREF="Database-Enumerator.html#t%3ASqlStateClass"
+>SqlStateClass</A
+>, <A HREF="Database-Enumerator.html#t%3ASqlStateSubClass"
+>SqlStateSubClass</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlStateClass"
+>SqlStateClass</A
+> = String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlStateSubClass"
+>SqlStateSubClass</A
+> = String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3APreparedStmt"
+>PreparedStmt</A
+> mark stmt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AwithPreparedStatement"
+>withPreparedStatement</A
+> :: (Typeable a, <A HREF="Database-Enumerator.html#t%3AIPrepared"
+>IPrepared</A
+> stmt sess bstmt bo) =&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> sess stmt -&gt; (<A HREF="Database-Enumerator.html#t%3APreparedStmt"
+>PreparedStmt</A
+> mark stmt -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a) -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AwithBoundStatement"
+>withBoundStatement</A
+> :: (Typeable a, <A HREF="Database-Enumerator.html#t%3AIPrepared"
+>IPrepared</A
+> stmt s bstmt bo) =&gt; <A HREF="Database-Enumerator.html#t%3APreparedStmt"
+>PreparedStmt</A
+> mark stmt -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> s stmt bo] -&gt; (bstmt -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s a) -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess =&gt; <A HREF="#t%3AStatement"
+>Statement</A
+> stmt sess q | stmt sess -&gt; q</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess =&gt; <A HREF="#t%3ACommand"
+>Command</A
+> stmt sess </TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess =&gt; <A HREF="#t%3AEnvInquiry"
+>EnvInquiry</A
+> inquirykey sess result | inquirykey sess -&gt; result</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3APreparationA"
+>PreparationA</A
+> sess stmt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess =&gt; <A HREF="#t%3AIPrepared"
+>IPrepared</A
+> stmt sess bound_stmt bo | stmt -&gt; bound_stmt, stmt -&gt; bo</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ABindA"
+>BindA</A
+> sess stmt bo</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess =&gt; <A HREF="#t%3ADBBind"
+>DBBind</A
+> a sess stmt bo | stmt -&gt; bo <SPAN CLASS="keyword"
+>where</SPAN
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindP"
+>bindP</A
+> :: a -&gt; <A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> sess stmt bo</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindP"
+>bindP</A
+> :: <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> a sess stmt bo =&gt; a -&gt; <A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> sess stmt bo</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess =&gt; <A HREF="#t%3AIQuery"
+>IQuery</A
+> q sess b | q -&gt; sess, q -&gt; b <SPAN CLASS="keyword"
+>where</SPAN
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcurrentRowNum"
+>currentRowNum</A
+> :: q -&gt; IO Int</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AdoQuery"
+>doQuery</A
+> :: (<A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> stmt sess q, QueryIteratee (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess) q i seed b, <A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> q sess b) =&gt; stmt -&gt; i -&gt; seed -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess seed</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="#t%3ADBType"
+>DBType</A
+> a q b | q -&gt; b</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AIterResult"
+>IterResult</A
+> seedType = Either seedType seedType</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AIterAct"
+>IterAct</A
+> m seedType = seedType -&gt; m (<A HREF="Database-Enumerator.html#t%3AIterResult"
+>IterResult</A
+> seedType)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcurrentRowNum"
+>currentRowNum</A
+> :: <A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> q sess b =&gt; q -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ANextResultSet"
+>NextResultSet</A
+> mark stmt = <A HREF="#v%3ANextResultSet"
+>NextResultSet</A
+> (<A HREF="Database-Enumerator.html#t%3APreparedStmt"
+>PreparedStmt</A
+> mark stmt)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ARefCursor"
+>RefCursor</A
+> a = <A HREF="#v%3ARefCursor"
+>RefCursor</A
+> a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcursorIsEOF"
+>cursorIsEOF</A
+> :: DBCursor mark (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s) a -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s Bool</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcursorCurrent"
+>cursorCurrent</A
+> :: DBCursor mark (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s) a -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcursorNext"
+>cursorNext</A
+> :: DBCursor mark (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s) a -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s (DBCursor mark (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s) a)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AwithCursor"
+>withCursor</A
+> :: (Typeable a, <A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> stmt sess q, QueryIteratee (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess) q i seed b, <A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> q sess b) =&gt; stmt -&gt; i -&gt; seed -&gt; (DBCursor mark (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess) seed -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a) -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3APosition"
+>Position</A
+> = Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AifNull"
+>ifNull</A
+> :: Maybe a -&gt; a -&gt; a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aresult"
+>result</A
+> :: Monad m =&gt; <A HREF="Database-Enumerator.html#t%3AIterAct"
+>IterAct</A
+> m a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aresult%27"
+>result'</A
+> :: Monad m =&gt; <A HREF="Database-Enumerator.html#t%3AIterAct"
+>IterAct</A
+> m a</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+><A NAME="1"
+>Usage
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>Let's look at some example code:
+</P
+><PRE
+> -- sample code, doesn't necessarily compile
+ module MyDbExample is
+
+ import Database.Oracle.Enumerator
+ import Database.Enumerator
+ ...
+
+ query1Iteratee :: (Monad m) =&gt; Int -&gt; String -&gt; Double -&gt; IterAct m [(Int, String, Double)]
+ query1Iteratee a b c accum = result' ((a, b, c):accum)
+
+ -- non-query actions.
+ otherActions session = do
+   execDDL (sql &quot;create table blah&quot;)
+   execDML (cmdbind &quot;insert into blah (...) values (?, ?, ?, ...)&quot; [bindP &quot;v1&quot;, bindP (1::Int), ...])
+   commit
+   -- Use withTransaction to delimit a transaction.
+   -- It will commit at the end, or rollback if an error occurs.
+   withTransaction Serialisable ( do
+     execDML (sql &quot;update blah ...&quot;)
+     execDML (sql &quot;insert into blah ...&quot;)
+     )
+
+ main :: IO ()
+ main = do
+   withSession (connect &quot;user&quot; &quot;password&quot; &quot;server&quot;) ( do
+     -- simple query, returning reversed list of rows.
+     r &lt;- doQuery (sql &quot;select a, b, c from x&quot;) query1Iteratee []
+     liftIO $ putStrLn $ show r
+     otherActions session
+     )
+</PRE
+><P
+>Notes:
+</P
+><UL
+><LI
+> connection is made by <TT
+><A HREF="Database-Enumerator.html#v%3AwithSession"
+>withSession</A
+></TT
+>,
+    which also disconnects when done i.e. <TT
+><A HREF="Database-Enumerator.html#v%3AwithSession"
+>withSession</A
+></TT
+>
+    delimits the connection.
+    You must pass it a connection action, which is back-end specific,
+    and created by calling the <TT
+><A HREF="Database-Sqlite-Enumerator.html#v%3Aconnect"
+>connect</A
+></TT
+>
+    function from the relevant back-end.
+</LI
+><LI
+> inside the session, the usual transaction delimiter commands are usable
+    e.g. <TT
+><A HREF="Database-Enumerator.html#v%3AbeginTransaction"
+>beginTransaction</A
+></TT
+> <TT
+><A HREF="Database-Enumerator.html#t%3AIsolationLevel"
+>IsolationLevel</A
+></TT
+>,
+    <TT
+><A HREF="Database-Enumerator.html#v%3Acommit"
+>commit</A
+></TT
+>, <TT
+><A HREF="Database-Enumerator.html#v%3Arollback"
+>rollback</A
+></TT
+>, and
+    <TT
+><A HREF="Database-Enumerator.html#v%3AwithTransaction"
+>withTransaction</A
+></TT
+>.
+    We also provide <TT
+><A HREF="Database-Enumerator.html#v%3AexecDML"
+>execDML</A
+></TT
+> and <TT
+><A HREF="Database-Enumerator.html#v%3AexecDDL"
+>execDDL</A
+></TT
+>.
+</LI
+><LI
+> non-DML and -DDL commands - i.e. queries - are processed by
+    <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+> (this is the API for our left-fold).
+    See more explanation and examples below in <EM
+>Iteratee Functions</EM
+> and
+    <EM
+>Bind Parameters</EM
+> sections.
+</LI
+></UL
+><P
+>The first argument to <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+> must be an instance of  
+ <TT
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+></TT
+>.
+ Each back-end will provide a useful set of <TT
+>Statement</TT
+> instances
+ and associated constructor functions for them.
+ For example, currently all back-ends have:
+</P
+><UL
+><LI
+> for basic, all-text statements (no bind variables, default row-caching)
+     which can be used as queries or commands: 
+</LI
+></UL
+><PRE
+>      sql &quot;select ...&quot;
+</PRE
+><UL
+><LI
+> for a select with bind variables:
+</LI
+></UL
+><PRE
+>      sqlbind &quot;select ?, ... where col = ? and ...&quot; [bindP ..., bindP ...]
+</PRE
+><UL
+><LI
+> for a select with bind variables and row caching:
+</LI
+></UL
+><PRE
+>      prefetch 100 &quot;select ?, ... where col = ? and ...&quot; [bindP ..., bindP ...]
+</PRE
+><UL
+><LI
+> for a DML command with bind variables:
+</LI
+></UL
+><PRE
+>      cmdbind &quot;insert into ... values (?, ?, ...)&quot; [bindP ..., bindP ...]
+</PRE
+><UL
+><LI
+> for a reusable prepared statement: we have to first create the
+     prepared statement, and then bind in a separate step.
+     This separation lets us re-use prepared statements:
+</LI
+></UL
+><PRE
+>      let stmt = prepareQuery (sql &quot;select ? ...&quot;)
+      withPreparedStatement stmt $ \pstmt -&gt;
+        withBoundStatement pstmt [bindP ..., bindP ...] $ \bstmt -&gt; do
+          result &lt;- doQuery bstmt iter seed
+          ...
+</PRE
+><P
+>The PostgreSQL backend additionally requires that when preparing statements,
+ you (1) give a name to the prepared statement,
+ and (2) specify types for the bind parameters.
+ The list of bind-types is created by applying the
+ <TT
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3AbindType"
+>bindType</A
+></TT
+> function
+ to dummy values of the appropriate types. e.g.
+</P
+><PRE
+> let stmt = prepareQuery &quot;stmtname&quot; (sql &quot;select ...&quot;) [bindType &quot;&quot;, bindType (0::Int)]
+ withPreparedStatement stmt $ \pstmt -&gt; ...
+</PRE
+><P
+>A longer explanation of prepared statements and
+ bind variables is in the Bind Parameters section below.
+</P
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="2"
+>Iteratee Functions
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+><TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+> takes an iteratee function, of n arguments.
+ Argument n is the accumulator (or seed).
+ For each row that is returned by the query,
+ the iteratee function is called with the data from that row in
+ arguments 1 to n-1, and the current accumulated value in the argument n.
+</P
+><P
+>The iteratee function returns the next value of the accumulator,
+ wrapped in an <TT
+><A HREF="Data-Either.html#t%3AEither"
+>Either</A
+></TT
+>.
+ If the <TT
+><A HREF="Data-Either.html#t%3AEither"
+>Either</A
+></TT
+> value is <TT
+>Left</TT
+>, then the query will terminate,
+ returning the wrapped accumulator/seed value.
+ If the value is <TT
+>Right</TT
+>, then the query will continue, with the next row
+ begin fed to the iteratee function, along with the new accumulator/seed value.
+</P
+><P
+>In the example above, <TT
+>query1Iteratee</TT
+> simply conses the new row (as a tuple)
+ to the front of the accumulator.
+ The initial seed passed to <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+> was an empty list.
+ Consing the rows to the front of the list results in a list
+ with the rows in reverse order.
+</P
+><P
+>The types of values that can be used as arguments to the iteratee function
+ are back-end specific; they must be instances of the class
+ <TT
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+></TT
+>.
+ Most backends directly support the usual lowest-common-denominator set
+ supported by most DBMS's: <TT
+><A HREF="Data-Int.html#t%3AInt"
+>Int</A
+></TT
+>, <TT
+><A HREF="Data-Char.html#t%3AString"
+>String</A
+></TT
+>,
+ <TT
+><A HREF="Prelude.html#t%3ADouble"
+>Double</A
+></TT
+>, <TT
+><A HREF="Data-Time.html#t%3AUTCTime"
+>UTCTime</A
+></TT
+>.
+ (<TT
+><A HREF="Data-Int.html#t%3AInt64"
+>Int64</A
+></TT
+> is often, but not always, supported.)
+</P
+><P
+>By directly support we mean there is type-specific marshalling code
+ implemented.
+ Indirect support for <TT
+><A HREF="Text-Read.html#t%3ARead"
+>Read</A
+></TT
+>- and <TT
+><A HREF="Text-Show.html#t%3AShow"
+>Show</A
+></TT
+>-able types
+ is supported by marshalling to and from <TT
+><A HREF="Data-Char.html#t%3AString"
+>String</A
+></TT
+>s.
+ This is done automatically by the back-end;
+ there is no need for user-code to perform the marshalling,
+ as long as instances of <TT
+><A HREF="Text-Read.html#t%3ARead"
+>Read</A
+></TT
+> and <TT
+><A HREF="Text-Show.html#t%3AShow"
+>Show</A
+></TT
+> are defined.
+</P
+><P
+>The iteratee function operates in the <TT
+><A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+></TT
+> monad,
+ so if you want to do IO in it you must use <TT
+><A HREF="Control-Monad-Trans.html#v%3AliftIO"
+>liftIO</A
+></TT
+>
+ (e.g. <TT
+>liftIO $ putStrLn &quot;boo&quot;</TT
+> ) to lift the IO action into <TT
+><A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+></TT
+>.
+</P
+><P
+>The iteratee function is not restricted to just constructing lists.
+ For example, a simple counter function would ignore its arguments,
+ and the accumulator would simply be the count e.g.
+</P
+><PRE
+> counterIteratee :: (Monad m) =&gt; Int -&gt; IterAct m Int
+ counterIteratee _ i = result' $ (1 + i)
+</PRE
+><P
+>The iteratee function that you pass to <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+>
+ needs type information,
+ at least for the arguments if not the return type (which is typically
+ determined by the type of the seed).
+ The type synonyms <TT
+><A HREF="Database-Enumerator.html#t%3AIterAct"
+>IterAct</A
+></TT
+> and <TT
+><A HREF="Database-Enumerator.html#t%3AIterResult"
+>IterResult</A
+></TT
+> give some convenience
+ in writing type signatures for iteratee functions:
+</P
+><PRE
+> type IterResult seedType = Either seedType seedType
+ type IterAct m seedType = seedType -&gt; m (IterResult seedType)
+</PRE
+><P
+>Without them, the type for <TT
+>counterIteratee</TT
+> would be:
+</P
+><PRE
+> counterIteratee :: (Monad m) =&gt; Int -&gt; Int -&gt; m (Either Int Int)
+</PRE
+><P
+>which doesn't seem so onerous, but for more elaborate seed types
+ (think large tuples) it certainly helps e.g.
+</P
+><PRE
+> iter :: Monad m =&gt;
+      String -&gt; Double -&gt; UTCTime -&gt; [(String, Double, UTCTime)]
+   -&gt; m (Either [(String, Double, UTCTime)] [(String, Double, UTCTime)] )
+</PRE
+><P
+>reduces to (by using <TT
+><A HREF="Database-Enumerator.html#t%3AIterAct"
+>IterAct</A
+></TT
+> and <TT
+><A HREF="Database-Enumerator.html#t%3AIterResult"
+>IterResult</A
+></TT
+>):
+</P
+><PRE
+> iter :: Monad m =&gt;
+      String -&gt; Double -&gt; UTCTime -&gt; IterAct m [(String, Double, UTCTime)]
+</PRE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="3"
+>result and result'
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>The <TT
+><A HREF="Database-Enumerator.html#v%3Aresult"
+>result</A
+></TT
+> (lazy) and <TT
+>result'</TT
+> (strict) functions are another convenient shorthand
+ for returning values from iteratee functions. The return type from an iteratee is actually
+ <TT
+>Either seed seed</TT
+>, where you return <TT
+>Right</TT
+> if you want processing to continue,
+ or <TT
+>Left</TT
+> if you want processing to stop before the result-set is exhausted.
+ The common case is:
+</P
+><PRE
+> query1Iteratee a b c accum = return (Right ((a, b, c):accum))
+</PRE
+><P
+>which we can write as
+</P
+><PRE
+> query1Iteratee a b c accum = result $ (a, b, c):accum)
+</PRE
+><P
+>We have lazy and strict versions of <TT
+>result</TT
+>. The strict version is almost certainly
+ the one you want to use. If you come across a case where the lazy function is useful,
+ please tell us about it. The lazy function tends to exhaust the stack for large result-sets,
+ whereas the strict function does not.
+ This is due to the accumulation of a large number of unevaluated thunks,
+ and will happen even for simple arithmetic operations such as counting or summing.
+</P
+><P
+>If you use the lazy function and you have stack/memory problems, do some profiling.
+ With GHC:
+</P
+><UL
+><LI
+> ensure the iteratee has its own cost-centre (make it a top-level function)
+</LI
+><LI
+> compile with <TT
+>-prof -auto-all</TT
+>
+</LI
+><LI
+> run with <TT
+>+RTS -p -hr -RTS</TT
+>
+</LI
+><LI
+> run <TT
+>hp2ps</TT
+> over the resulting <TT
+>.hp</TT
+> file to get a <TT
+>.ps</TT
+> document, and take a look at it.
+    Retainer sets are listed on the RHS, and are prefixed with numbers e.g. (13)CAF, (2)SYSTEM.
+    At the bottom of the <TT
+>.prof</TT
+> file you'll find the full descriptions of the retainer sets.
+    Match the number in parentheses on the <TT
+>.ps</TT
+> graph with a SET in the <TT
+>.prof</TT
+> file;
+    the one at the top of the <TT
+>.ps</TT
+> graph is the one using the most memory.
+</LI
+></UL
+><P
+>You'll probably find that the lazy iteratee is consuming all of the stack with lazy thunks,
+ which is why we recommend the strict function.
+</P
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="4"
+>Rank-2 types, ($), and the monomorphism restriction
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>In some examples we use the application operator ($) instead of parentheses
+ (some might argue that this is a sign of developer laziness).
+ At first glance, ($) and conventional function application via juxtaposition
+ seem to be interchangeable e.g.
+</P
+><PRE
+> liftIO (putStrLn (show x))
+</PRE
+><P
+>looks equivalent to
+</P
+><PRE
+> liftIO $ putStrLn $ show x
+</PRE
+><P
+>But they're not, because Haskell's type system gives us a nice compromise.
+</P
+><P
+>In a Hindley-Milner type system (like ML) there is no difference between
+ ($) and function application, because polymorphic functions are not
+ first-class and cannot be passed to other functions.
+ At the other end of the scale, ($) and function application in System F
+ are equivalent, because polymorphic functions can be passed to other
+ functions. However, type inference in System F is undecidable.
+</P
+><P
+>Haskell hits the sweet spot: maintaining full inference,
+ and permitting rank-2 polymorphism, in exchange for very few
+ type annotations. Only functions that take polymorphic functions (and
+ thus are higher-rank) need type signatures. Rank-2 types can't be
+ inferred. The function ($) is a regular, rank-1 function, and so
+ it can't take polymorphic functions as arguments and return
+ polymorphic functions.
+</P
+><P
+>Here's an example where ($) fails: 
+ we supply a simple test program in the README file.
+ If you change the <TT
+>withSession</TT
+> line to use ($), like so
+ (and remove the matching end-parenthese):
+</P
+><PRE
+>   withSession (connect &quot;sqlite_db&quot;) $ do
+</PRE
+><P
+>then you get the error:
+</P
+><PRE
+> Main.hs:7:38:
+     Couldn't match expected type `forall mark. DBM mark Session a'
+            against inferred type `a1 b'
+     In the second argument of `($)', namely
+       ...
+</PRE
+><P
+>Another way of rewriting it is like this, where we separate the
+ <TT
+><A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+></TT
+> action into another function:
+</P
+><PRE
+> {-# OPTIONS -fglasgow-exts #-}
+ module Main where
+ import Database.Sqlite.Enumerator
+ import Control.Monad.Trans (liftIO)
+ main = flip catchDB reportRethrow $
+   withSession (connect &quot;sqlite_db&quot;) hello
+
+ hello = withTransaction RepeatableRead $ do
+     let iter (s::String) (_::String) = result s
+     result &lt;- doQuery (sql &quot;select 'Hello world.'&quot;) iter &quot;&quot;
+     liftIO (putStrLn result)
+</PRE
+><P
+>which gives this error:
+</P
+><PRE
+> Main.hs:9:2:
+     Inferred type is less polymorphic than expected
+       Quantified type variable `mark' is mentioned in the environment:
+         hello :: DBM mark Session () (bound at Main.hs:15:0)
+         ...
+</PRE
+><P
+>This is just the monomorphism restriction in action.
+ Sans a type signature, the function hello is monomorphised
+ (that is, mark is replaced with (), per GHC rules).
+ This is easily fixed by adding this type declaration:
+</P
+><PRE
+> hello :: DBM mark Session ()
+</PRE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="5"
+>Bind Parameters
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>Support for bind variables varies between DBMS's.
+</P
+><P
+>We call <TT
+><A HREF="Database-Enumerator.html#v%3AwithPreparedStatement"
+>withPreparedStatement</A
+></TT
+> function to prepare
+ the statement, and then call <TT
+><A HREF="Database-Enumerator.html#v%3AwithBoundStatement"
+>withBoundStatement</A
+></TT
+>
+ to provide the bind values and execute the query.
+ The value returned by <TT
+><A HREF="Database-Enumerator.html#v%3AwithBoundStatement"
+>withBoundStatement</A
+></TT
+>
+ is an instance of the <TT
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+></TT
+> class,
+ so it can be passed to <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+> for result-set processing.
+</P
+><P
+>When we call <TT
+><A HREF="Database-Enumerator.html#v%3AwithPreparedStatement"
+>withPreparedStatement</A
+></TT
+>, we must pass
+ it a &quot;preparation action&quot;, which is simply an action that returns
+ the prepared query. The function to create this action varies between backends,
+ and by convention is called <TT
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3AprepareQuery"
+>prepareQuery</A
+></TT
+>.
+ For DML statements, you must use <TT
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3AprepareCommand"
+>prepareCommand</A
+></TT
+>,
+ as the library needs to do something different depending on whether or not the
+ statement returns a result-set.
+</P
+><P
+>For queries with large result-sets, we provide 
+ <TT
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3AprepareLargeQuery"
+>prepareLargeQuery</A
+></TT
+>,
+ which takes an extra parameter: the number of rows to prefetch
+ in a network call to the server.
+ This aids performance in two ways:
+ 1. you can limit the number of rows that come back to the
+ client, in order to use less memory, and
+ 2. the client library will cache rows, so that a network call to
+ the server is not required for every row processed.
+</P
+><P
+>With PostgreSQL, we must specify the types of the bind parameters
+ when the query is prepared, so the <TT
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3AprepareQuery"
+>prepareQuery</A
+></TT
+>
+ function takes a list of <TT
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3AbindType"
+>bindType</A
+></TT
+> values.
+ Also, PostgreSQL requires that prepared statements are named,
+ although you can use &quot;&quot; as the name.
+</P
+><P
+>With Sqlite and Oracle, we simply pass the query text to
+ <TT
+><A HREF="Database-PostgreSQL-Sqlite.html#v%3AprepareQuery"
+>prepareQuery</A
+></TT
+>,
+ so things are slightly simpler for these backends.
+</P
+><P
+>Perhaps an example will explain it better:
+</P
+><PRE
+> postgresBindExample = do
+   let
+     query = sql &quot;select blah from blahblah where id = ? and code = ?&quot;
+     iter :: (Monad m) =&gt; String -&gt; IterAct m [String]
+     iter s acc = result $ s:acc
+     bindVals = [bindP (12345::Int), bindP &quot;CODE123&quot;]
+     bindTypes = [bindType (0::Int), bindType &quot;&quot;]
+   withPreparedStatement (prepareQuery &quot;stmt1&quot; query bindTypes) $ \pstmt -&gt; do
+     withBoundStatement pstmt bindVals $ \bstmt -&gt; do
+       actual &lt;- doQuery bstmt iter []
+       liftIO (print actual)
+</PRE
+><P
+>Note that we pass <TT
+>bstmt</TT
+> to <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+>;
+ this is the bound statement object created by
+ <TT
+><A HREF="Database-Enumerator.html#v%3AwithBoundStatement"
+>withBoundStatement</A
+></TT
+>.
+</P
+><P
+>The Oracle/Sqlite example code is almost the same, except for the
+ call to <TT
+><A HREF="Database-Sqlite-Enumerator.html#v%3AprepareQuery"
+>prepareQuery</A
+></TT
+>:
+</P
+><PRE
+> sqliteBindExample = do
+   let
+     query = sql &quot;select blah from blahblah where id = ? and code = ?&quot;
+     iter :: (Monad m) =&gt; String -&gt; IterAct m [String]
+     iter s acc = result $ s:acc
+     bindVals = [bindP (12345::Int), bindP &quot;CODE123&quot;]
+   withPreparedStatement (prepareQuery query) $ \pstmt -&gt; do
+     withBoundStatement pstmt bindVals $ \bstmt -&gt; do
+       actual &lt;- doQuery bstmt iter []
+       liftIO (print actual)
+</PRE
+><P
+>It can be a bit tedious to always use the <TT
+>withPreparedStatement+withBoundStatement</TT
+>
+ combination, so for the case where you don't plan to re-use the query,
+ we support a short-cut for bundling the query text and parameters.
+ The next example is valid for PostgreSQL, Sqlite, and Oracle
+ (the Sqlite implementation provides a dummy <TT
+><A HREF="Database-Sqlite-Enumerator.html#v%3Aprefetch"
+>prefetch</A
+></TT
+>
+ function to ensure we have a consistent API).
+ Sqlite has no facility for prefetching - it's an embedded database, so no
+ network round-trip - so the Sqlite implementation ignores the prefetch count:
+</P
+><PRE
+> bindShortcutExample = do
+   let
+     iter :: (Monad m) =&gt; String -&gt; IterAct m [String]
+     iter s acc = result $ s:acc
+     bindVals = [bindP (12345::Int), bindP &quot;CODE123&quot;]
+     query = prefetch 1000 &quot;select blah from blahblah where id = ? and code = ?&quot; bindVals
+   actual &lt;- doQuery query iter []
+   liftIO (print actual)
+</PRE
+><P
+>A caveat of using prefetch with PostgreSQL is that you must be inside a transaction.
+ This is because the PostgreSQL implementation uses a cursor and &quot;FETCH FORWARD&quot;
+ to implement fetching a block of rows in a single network call,
+ and PostgreSQL requires that cursors are only used inside transactions.
+ It can be as simple as wrapping calls to <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+> by
+ <TT
+><A HREF="Database-Enumerator.html#v%3AwithTransaction"
+>withTransaction</A
+></TT
+>,
+ or you may prefer to delimit your transactions elsewhere (the API supports
+ <TT
+><A HREF="Database-InternalEnumerator.html#v%3AbeginTransaction"
+>beginTransaction</A
+></TT
+> and
+ <TT
+><A HREF="Database-InternalEnumerator.html#v%3Acommit"
+>commit</A
+></TT
+>, if you prefer to use them):
+</P
+><PRE
+>   withTransaction RepeatableRead $ do
+     actual &lt;- doQuery query iter []
+     liftIO (print actual)
+</PRE
+><P
+>You may have noticed that for <TT
+><A HREF="Data-Int.html#t%3AInt"
+>Int</A
+></TT
+> and <TT
+><A HREF="Prelude.html#t%3ADouble"
+>Double</A
+></TT
+> literal
+ bind values, we have to tell the compiler the type of the literal.
+ This is due to interaction with the numeric literal defaulting mechanism.
+ For non-numeric literals the compiler can (usually) determine the correct types to use.
+</P
+><P
+>If you omit type information for numeric literals, from GHC the error
+ message looks something like this:
+</P
+><PRE
+> Database/PostgreSQL/Test/Enumerator.lhs:194:4:
+     Overlapping instances for Database.InternalEnumerator.DBBind a
+                                  Session
+                                  Database.PostgreSQL.PGEnumerator.PreparedStmt
+                                  Database.PostgreSQL.PGEnumerator.BindObj
+       arising from use of `bindP' at Database/PostgreSQL/Test/Enumerator.lhs:194:4-8
+     Matching instances:
+       Imported from Database.PostgreSQL.PGEnumerator:
+     instance (Database.InternalEnumerator.DBBind (Maybe a)
+                              Session
+                              Database.PostgreSQL.PGEnumerator.PreparedStmt
+                              Database.PostgreSQL.PGEnumerator.BindObj) =&gt;
+          Database.InternalEnumerator.DBBind a
+                             Session
+                             Database.PostgreSQL.PGEnumerator.PreparedStmt
+                             Database.PostgreSQL.PGEnumerator.BindObj
+       Imported from Database.PostgreSQL.PGEnumerator:
+     instance Database.InternalEnumerator.DBBind (Maybe Double)
+                        ....
+</PRE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="6"
+>Multiple (and nested) Result Sets
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>Support for returning multiple result sets from a single
+ statement exists for PostgreSQL and Oracle.
+ Such functionality does not exist in Sqlite.
+</P
+><P
+>The general idea is to invoke a database procedure or function which
+ returns cursor variables. The variables can be processed by
+ <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+> in one of two styles: linear or nested.
+</P
+><P
+><EM
+>Linear style:</EM
+>
+</P
+><P
+>If we assume the existence of the following PostgreSQL function,
+ which is used in the test suite in <A HREF="Database-PostgreSQL-Test-Enumerator.html"
+>Database.PostgreSQL.Test.Enumerator</A
+>:
+</P
+><PRE
+> CREATE OR REPLACE FUNCTION takusenTestFunc() RETURNS SETOF refcursor AS $$
+ DECLARE refc1 refcursor; refc2 refcursor;
+ BEGIN
+     OPEN refc1 FOR SELECT n*n from t_natural where n &lt; 10 order by 1;
+     RETURN NEXT refc1;
+     OPEN refc2 FOR SELECT n, n*n, n*n*n from t_natural where n &lt; 10 order by 1;
+     RETURN NEXT refc2;
+ END;$$ LANGUAGE plpgsql;
+</PRE
+><P
+>... then this code shows how linear processing of cursors would be done:
+</P
+><PRE
+>   withTransaction RepeatableRead $ do
+   withPreparedStatement (prepareQuery &quot;stmt1&quot; (sql &quot;select * from takusenTestFunc()&quot;) []) $ \pstmt -&gt; do
+   withBoundStatement pstmt [] $ \bstmt -&gt; do
+     dummy &lt;- doQuery bstmt iterMain []
+     result1 &lt;- doQuery (NextResultSet pstmt) iterRS1 []
+     result2 &lt;- doQuery (NextResultSet pstmt) iterRS2 []
+   where
+     iterMain :: (Monad m) =&gt; (RefCursor String) -&gt; IterAct m [RefCursor String]
+     iterMain c acc = result (acc ++ [c])
+     iterRS1 :: (Monad m) =&gt; Int -&gt; IterAct m [Int]
+     iterRS1 i acc = result (acc ++ [i])
+     iterRS2 :: (Monad m) =&gt; Int -&gt; Int -&gt; Int -&gt; IterAct m [(Int, Int, Int)]
+     iterRS2 i i2 i3 acc = result (acc ++ [(i, i2, i3)])
+</PRE
+><P
+>Notes:
+</P
+><UL
+><LI
+> the use of a <TT
+><A HREF="Database-Enumerator.html#t%3ARefCursor"
+>RefCursor</A
+></TT
+> <TT
+><A HREF="Data-Char.html#t%3AString"
+>String</A
+></TT
+>
+    type in the iteratee function indicates
+    to the backend that it should save each cursor value returned,
+    which it does by stuffing them into a list attached to the
+    prepared statement object.
+    This means that we <EM
+>must</EM
+> use <TT
+><A HREF="Database-Enumerator.html#v%3AwithPreparedStatement"
+>withPreparedStatement</A
+></TT
+>
+    to create a prepared statement object; the prepared statament oject
+    is the container for the cursors returned.
+</LI
+><LI
+> in this example we choose to discard the results of the first iteratee.
+    This is not necessary, but in this case the only column is a
+    <TT
+><A HREF="Database-Enumerator.html#t%3ARefCursor"
+>RefCursor</A
+></TT
+>, and the values are already saved
+    in the prepared statement object.
+</LI
+><LI
+> saved cursors are consumed one-at-a-time by calling <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+>,
+    passing <TT
+><A HREF="Database-Enumerator.html#t%3ANextResultSet"
+>NextResultSet</A
+></TT
+> <TT
+>pstmt</TT
+>
+    (i.e. passing the prepared statement oject wrapped by
+    <TT
+><A HREF="Database-Enumerator.html#t%3ANextResultSet"
+>NextResultSet</A
+></TT
+>).
+    This simply pulls the next cursor off the list
+    - they're processed in the order they were pushed on (FIFO) -
+    and processes it with the given iteratee.
+</LI
+><LI
+> if you try to process too many cursors i.e. make too many calls
+    to <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+> passing <TT
+><A HREF="Database-Enumerator.html#t%3ANextResultSet"
+>NextResultSet</A
+></TT
+> <TT
+>pstmt</TT
+>,
+    then an exception will be thrown.
+    OTOH, failing to process returned cursors will not raise errors,
+    but the cursors will remain open on the server according to whatever scoping
+    rules the server applies.
+    For PostgreSQL, this will be until the transaction (or session) ends.
+</LI
+></UL
+><P
+><EM
+>Nested style:</EM
+>
+</P
+><P
+>The linear style of cursor processing is the only style supported by
+ MS SQL Server and ODBC (which we do not yet support).
+ However, PostgreSQL and Oracle also support using nested cursors in queries.
+</P
+><P
+>Again for PostgreSQL, assuming we have these functions in the database:
+</P
+><PRE
+> CREATE OR REPLACE FUNCTION takusenTestFunc(lim int4) RETURNS refcursor AS $$
+ DECLARE refc refcursor;
+ BEGIN
+     OPEN refc FOR SELECT n, takusenTestFunc2(n) from t_natural where n &lt; lim order by n;
+     RETURN refc;
+ END; $$ LANGUAGE plpgsql;
+</PRE
+><PRE
+> CREATE OR REPLACE FUNCTION takusenTestFunc2(lim int4) RETURNS refcursor AS $$
+ DECLARE refc refcursor;
+ BEGIN
+     OPEN refc FOR SELECT n from t_natural where n &lt; lim order by n;
+     RETURN refc;
+ END; $$ LANGUAGE plpgsql;
+</PRE
+><P
+>... then this code shows how nested queries might work:
+</P
+><PRE
+> selectNestedMultiResultSet = do
+   let
+     q = &quot;SELECT n, takusenTestFunc(n) from t_natural where n &lt; 10 order by n&quot;
+     iterMain   (i::Int) (c::RefCursor String) acc = result' ((i,c):acc)
+     iterInner  (i::Int) (c::RefCursor String) acc = result' ((i,c):acc)
+     iterInner2 (i::Int) acc = result' (i:acc)
+   withTransaction RepeatableRead $ do
+     rs &lt;- doQuery (sql q) iterMain []
+     flip mapM_ rs $ \(outer, c) -&gt; do
+       rs &lt;- doQuery c iterInner []
+       flip mapM_ rs $ \(inner, c) -&gt; do
+         rs &lt;- doQuery c iterInner2 []
+         flip mapM_ rs $ \i -&gt; do
+           liftIO (putStrLn (show outer ++ &quot; &quot; ++ show inner ++ &quot; &quot; ++ show i))
+</PRE
+><P
+>Just to make it clear: the outer query returns a result-set that includes
+ a <TT
+><A HREF="Database-Enumerator.html#t%3ARefCursor"
+>RefCursor</A
+></TT
+> column. Each cursor from that column is passed to
+ <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+> to process it's result-set;
+ here we use <TT
+><A HREF="Control-Monad.html#v%3AmapM_"
+>mapM_</A
+></TT
+> to apply an IO action to the list returned by
+ <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+>.
+</P
+><P
+>For Oracle the example is slightly different.
+ The reason it's different is that:
+</P
+><UL
+><LI
+> Oracle requires that the parent cursor must remain open
+    while processing the children
+    (in the PostgreSQL example, <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+>
+    closes the parent cursor after constructing the list,
+    before the list is processed. This is OK because PostgreSQL
+    keeps the child cursors open on the server until they are explicitly
+    closed, or the transaction or session ends).
+</LI
+><LI
+> our current Oracle implementation prevents marshalling
+    of the cursor in the result-set buffer to a Haskell value,
+    so each fetch overwrites the buffer value with a new cursor.
+    This means you have to fully process a given cursor before
+    fetching the next one.
+</LI
+></UL
+><P
+>Contrast this with the PostgreSQL example above,
+ where the entire result-set is processed to give a
+ list of RefCursor values, and then we run a list of actions
+ over this list with <TT
+><A HREF="Control-Monad.html#v%3AmapM_"
+>mapM_</A
+></TT
+>.
+ This is possible because PostgreSQL refcursors are just the
+ database cursor names, which are Strings, which we can marshal
+ to Haskell values easily.
+</P
+><PRE
+> selectNestedMultiResultSet = do
+   let
+     q = &quot;select n, cursor(SELECT nat2.n, cursor&quot;
+         ++ &quot;     (SELECT nat3.n from t_natural nat3 where nat3.n &lt; nat2.n order by n)&quot;
+         ++ &quot;   from t_natural nat2 where nat2.n &lt; nat.n order by n)&quot;
+         ++ &quot; from t_natural nat where n &lt; 10 order by n&quot;
+     iterMain   (outer::Int) (c::RefCursor StmtHandle) acc = do
+       rs &lt;- doQuery c (iterInner outer) []
+       result' ((outer,c):acc)
+     iterInner outer (inner::Int) (c::RefCursor StmtHandle) acc = do
+       rs &lt;- doQuery c (iterInner2 outer inner) []
+       result' ((inner,c):acc)
+     iterInner2 outer inner (i::Int) acc = do
+       liftIO (putStrLn (show outer ++ &quot; &quot; ++ show inner ++ &quot; &quot; ++ show i))
+       result' (i:acc)
+   withTransaction RepeatableRead $ do
+     rs &lt;- doQuery (sql q) iterMain []
+     return ()
+</PRE
+><P
+>Note that the PostgreSQL example can also be written like this
+ (except, of course, that the actual query text is that
+ from the PostgreSQL example).
+</P
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+><A NAME="7"
+>Sessions and Transactions
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ADBM"
+></A
+><B
+>DBM</B
+> mark sess a</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:DBM')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:DBM" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> si =&gt; <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark si)</TD
+></TR
+><TR
+><TD CLASS="decl"
+>(<A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess, ??? a sess) =&gt; Functor (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a)</TD
+></TR
+><TR
+><TD CLASS="decl"
+>(<A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess, ??? a sess) =&gt; Monad (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a)</TD
+></TR
+><TR
+><TD CLASS="decl"
+>(<A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess, ??? a sess) =&gt; MonadFix (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a)</TD
+></TR
+><TR
+><TD CLASS="decl"
+>(<A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess, ??? a sess) =&gt; MonadIO (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a)</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A NAME="t%3AISession"
+></A
+><B
+>ISession</B
+> sess </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="ndoc"
+><P
+>The <TT
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+></TT
+> class describes a database session to a particular
+ DBMS.  Oracle has its own Session object, SQLite has its own
+ session object (which maintains the connection handle to the database
+ engine and other related stuff). Session objects for different databases
+ normally have different types -- yet they all belong to the class ISession
+ so we can do generic operations like <TT
+>commit</TT
+>, <TT
+>execDDL</TT
+>, etc. 
+ in a database-independent manner.
+</P
+><P
+>Session objects per se are created by database connection/login functions.
+</P
+><P
+>The class <TT
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+></TT
+> is thus an interface between low-level (and
+ database-specific) code and the Enumerator, database-independent
+ code.
+ The <TT
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+></TT
+> class is NOT visible to the end user -- neither the class,
+ nor any of its methods.
+</P
+><P
+>The <TT
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+></TT
+> class describes the mapping from connection object to
+ the session object. The connection object is created by the end user
+ (and this is how the end user tells which particular back end he wants).
+ The session object is not accessible by the end user in any way.
+ Even the type of the session object should be hidden!
+</P
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:ISession')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:ISession" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AConnectA"
+></A
+><B
+>ConnectA</B
+> sess</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="ndoc"
+>A wrapper around the action to open the database. That wrapper is not
+ exported to the end user. The only reason for the wrapper is to
+ guarantee that the only thing to do with the result of
+ <TT
+><A HREF="Database-Enumerator-Sqlite.html#v%3Aconnect"
+>connect</A
+></TT
+> function is to pass it out
+ directly to <TT
+><A HREF="Database-Enumerator.html#v%3AwithSession"
+>withSession</A
+></TT
+>.
+</TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:ConnectA')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:ConnectA" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+>??? sess =&gt; Typeable (<A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> sess)</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AwithSession"
+></A
+><B
+>withSession</B
+> :: (Typeable a, <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess) =&gt; <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> sess -&gt; (<SPAN CLASS="keyword"
+>forall</SPAN
+> mark . <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Typeable constraint is to prevent the leakage of Session and other
+ marked objects.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AwithContinuedSession"
+></A
+><B
+>withContinuedSession</B
+> :: (Typeable a, <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess) =&gt; <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> sess -&gt; (<SPAN CLASS="keyword"
+>forall</SPAN
+> mark . <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a) -&gt; IO (a, <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> sess)</TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>Persistent database connections. 
+ This issue has been brought up by Shanky Surana. The following design
+ is inspired by that exchange.
+</P
+><P
+>On one hand, implementing persistent connections is easy. One may say we should
+ have added them long time ago, to match HSQL, HDBC, and similar
+ database interfaces. Alas, implementing persistent connection
+ safely is another matter. The simplest design is like the following
+</P
+><PRE
+> withContinuedSession :: (Typeable a, IE.ISession sess) =&gt; 
+     IE.ConnectA sess -&gt; (forall mark. DBM mark sess a) -&gt; 
+     IO (a, IE.ConnectA sess)
+ withContinuedSession (IE.ConnectA connecta) m = do
+     conn &lt;- connecta
+     r &lt;- runReaderT (unDBM m) conn
+     return (r,(return conn))
+</PRE
+><P
+>so that the connection object is returned as the result and can be
+ used again with withContinuedSession or withSession. The problem is
+ that nothing prevents us from writing:
+</P
+><PRE
+>     (r1,conn) &lt;- withContinuedSession (connect &quot;...&quot;) query1
+     r2        &lt;- withSession conn query2
+     r3        &lt;- withSession conn query3
+</PRE
+><P
+>That is, we store the suspended connection and then use it twice.
+ But the first withSession closes the connection. So, the second
+ withSession gets an invalid session object. Invalid in a sense that
+ even memory may be deallocated, so there is no telling what happens
+ next. Also, as we can see, it is difficult to handle errors and
+ automatically dispose of the connections if the fatal error is
+ encountered.
+</P
+><P
+>All these problems are present in other interfaces...  In the
+ case of a suspended connection, the problem is how to enforce the
+ <EM
+>linear</EM
+> access to a variable. It can be enforced, via a
+ state-changing monad. The implementation below makes
+ the non-linear use of a suspended connection a run-time checkable
+ condition. It will be generic and safe - fatal errors close the
+ connection, an attempt to use a closed connection raises an error, and
+ we cannot reuse a connection. We have to write:
+</P
+><PRE
+>     (r1, conn1) &lt;- withContinuedSession conn  ...
+     (r2, conn2) &lt;- withContinuedSession conn1 ...
+     (r3, conn3) &lt;- withContinuedSession conn2 ...
+</PRE
+><P
+>etc. If we reuse a suspended connection or use a closed connection,
+ we get a run-time (exception). That is of course not very
+ satisfactory - and yet better than a segmentation fault. 
+</P
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Acommit"
+></A
+><B
+>commit</B
+> :: <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> s =&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Arollback"
+></A
+><B
+>rollback</B
+> :: <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> s =&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbeginTransaction"
+></A
+><B
+>beginTransaction</B
+> :: (MonadReader s (ReaderT s IO), <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> s) =&gt; <A HREF="Database-Enumerator.html#t%3AIsolationLevel"
+>IsolationLevel</A
+> -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AwithTransaction"
+></A
+><B
+>withTransaction</B
+> :: <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> s =&gt; <A HREF="Database-Enumerator.html#t%3AIsolationLevel"
+>IsolationLevel</A
+> -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s a -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Perform an action as a transaction: commit afterwards,
+ unless there was an exception, in which case rollback.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AIsolationLevel"
+></A
+><B
+>IsolationLevel</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AReadUncommitted"
+></A
+><B
+>ReadUncommitted</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AReadCommitted"
+></A
+><B
+>ReadCommitted</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ARepeatableRead"
+></A
+><B
+>RepeatableRead</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ASerialisable"
+></A
+><B
+>Serialisable</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ASerializable"
+></A
+><B
+>Serializable</B
+></TD
+><TD CLASS="rdoc"
+>for alternative spellers
+</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:IsolationLevel')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:IsolationLevel" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+>Enum <A HREF="Database-Enumerator.html#t%3AIsolationLevel"
+>IsolationLevel</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>Eq <A HREF="Database-Enumerator.html#t%3AIsolationLevel"
+>IsolationLevel</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>Ord <A HREF="Database-Enumerator.html#t%3AIsolationLevel"
+>IsolationLevel</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show <A HREF="Database-Enumerator.html#t%3AIsolationLevel"
+>IsolationLevel</A
+></TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AexecDDL"
+></A
+><B
+>execDDL</B
+> :: <A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> stmt s =&gt; stmt -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s ()</TD
+></TR
+><TR
+><TD CLASS="doc"
+>DDL operations don't manipulate data, so we return no information.
+ If there is a problem, an exception will be raised.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AexecDML"
+></A
+><B
+>execDML</B
+> :: <A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> stmt s =&gt; stmt -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s Int</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Returns the number of rows affected.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Ainquire"
+></A
+><B
+>inquire</B
+> :: <A HREF="Database-Enumerator.html#t%3AEnvInquiry"
+>EnvInquiry</A
+> key s result =&gt; key -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s result</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Allows arbitrary actions to be run the DBM monad.
+ The back-end developer must supply instances of EnvInquiry,
+ which is hidden away in <A HREF="Database-InternalEnumerator.html"
+>Database.InternalEnumerator</A
+>.
+ An example of this is <TT
+><A HREF="Database-Sqlite-Enumerator.html#t%3ALastInsertRowid"
+>LastInsertRowid</A
+></TT
+>.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+><A NAME="8"
+>Exceptions and handlers
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ADBException"
+></A
+><B
+>DBException</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ADBError"
+></A
+><B
+>DBError</B
+> <A HREF="Database-Enumerator.html#t%3ASqlState"
+>SqlState</A
+> Int String</TD
+><TD CLASS="rdoc"
+>DBMS error message.
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ADBFatal"
+></A
+><B
+>DBFatal</B
+> <A HREF="Database-Enumerator.html#t%3ASqlState"
+>SqlState</A
+> Int String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ADBUnexpectedNull"
+></A
+><B
+>DBUnexpectedNull</B
+> <A HREF="Database-Enumerator.html#t%3ARowNum"
+>RowNum</A
+> <A HREF="Database-Enumerator.html#t%3AColNum"
+>ColNum</A
+></TD
+><TD CLASS="rdoc"
+>the iteratee function used for queries accepts both nullable (Maybe) and
+ non-nullable types. If the query itself returns a null in a column where a
+ non-nullable type was specified, we can't handle it, so DBUnexpectedNull is thrown.
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ADBNoData"
+></A
+><B
+>DBNoData</B
+></TD
+><TD CLASS="rdoc"
+>Thrown by cursor functions if you try to fetch after the end.
+</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:DBException')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:DBException" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+>Show <A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>Typeable <A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+></TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AformatDBException"
+></A
+><B
+>formatDBException</B
+> :: <A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; String</TD
+></TR
+><TR
+><TD CLASS="doc"
+>A show for <TT
+><A HREF="Database-InteralEnumerator.html#t%3ADBException"
+>DBException</A
+></TT
+>s.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbasicDBExceptionReporter"
+></A
+><B
+>basicDBExceptionReporter</B
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; <A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; m ()</TD
+></TR
+><TR
+><TD CLASS="doc"
+>This simple handler reports the error to <TT
+>stdout</TT
+> and swallows it
+ i.e. it doesn't propagate.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AreportRethrow"
+></A
+><B
+>reportRethrow</B
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; <A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; m a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>This handler reports the error and propagates it
+ (usually to force the program to halt).
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AreportRethrowMsg"
+></A
+><B
+>reportRethrowMsg</B
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; String -&gt; <A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; m a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Same as reportRethrow, but you can prefix some text to the error
+ (perhaps to indicate which part of your program raised it).
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcatchDB"
+></A
+><B
+>catchDB</B
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; m a -&gt; (<A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; m a) -&gt; m a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Catch <TT
+><A HREF="Database-InteralEnumerator.html#t%3ADBException"
+>DBException</A
+></TT
+>s thrown in the <TT
+><A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+></TT
+>
+ monad.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcatchDBError"
+></A
+><B
+>catchDBError</B
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; Int -&gt; m a -&gt; (<A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; m a) -&gt; m a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>If you want to trap a specific error number, use this.
+ It passes anything else up.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AignoreDBError"
+></A
+><B
+>ignoreDBError</B
+> :: <A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>CaughtMonadIO</A
+> m =&gt; Int -&gt; m a -&gt; m a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Analogous to <TT
+><A HREF="Database-Enumerator.html#v%3AcatchDBError"
+>catchDBError</A
+></TT
+>, but ignores specific errors instead
+ (propagates anything else).
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AthrowDB"
+></A
+><B
+>throwDB</B
+> :: <A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+> -&gt; a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Throw a DBException. It's just a type-specific <TT
+><A HREF="Control-Exception.html#v%3AthrowDyn"
+>throwDyn</A
+></TT
+>.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AColNum"
+></A
+><B
+>ColNum</B
+> = Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ARowNum"
+></A
+><B
+>RowNum</B
+> = Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlState"
+></A
+><B
+>SqlState</B
+> = (<A HREF="Database-Enumerator.html#t%3ASqlStateClass"
+>SqlStateClass</A
+>, <A HREF="Database-Enumerator.html#t%3ASqlStateSubClass"
+>SqlStateSubClass</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlStateClass"
+></A
+><B
+>SqlStateClass</B
+> = String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlStateSubClass"
+></A
+><B
+>SqlStateSubClass</B
+> = String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+><A NAME="9"
+>Preparing and Binding
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3APreparedStmt"
+></A
+><B
+>PreparedStmt</B
+> mark stmt</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AwithPreparedStatement"
+></A
+><B
+>withPreparedStatement</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: (Typeable a, <A HREF="Database-Enumerator.html#t%3AIPrepared"
+>IPrepared</A
+> stmt sess bstmt bo)</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>=&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> sess stmt</TD
+><TD CLASS="rdoc"
+>preparation action to create prepared statement;
+   this action is usually created by <TT
+>prepareQuery/Command</TT
+>
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; (<A HREF="Database-Enumerator.html#t%3APreparedStmt"
+>PreparedStmt</A
+> mark stmt -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a)</TD
+><TD CLASS="rdoc"
+>DBM action that takes a prepared statement
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="ndoc" COLSPAN="2"
+><P
+>Prepare a statement and run a DBM action over it.
+ This gives us the ability to re-use a statement,
+ for example by passing different bind values for each execution.
+</P
+><P
+>The Typeable constraint is to prevent the leakage of marked things.
+ The type of bound statements should not be exported (and should not be
+ in Typeable) so the bound statement can't leak either.
+</P
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AwithBoundStatement"
+></A
+><B
+>withBoundStatement</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: (Typeable a, <A HREF="Database-Enumerator.html#t%3AIPrepared"
+>IPrepared</A
+> stmt s bstmt bo)</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>=&gt; <A HREF="Database-Enumerator.html#t%3APreparedStmt"
+>PreparedStmt</A
+> mark stmt</TD
+><TD CLASS="rdoc"
+>prepared statement created by withPreparedStatement
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> s stmt bo]</TD
+><TD CLASS="rdoc"
+>bind values
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; (bstmt -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s a)</TD
+><TD CLASS="rdoc"
+>action to run over bound statement
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s a</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="ndoc" COLSPAN="2"
+><P
+>Applies a prepared statement to bind variables to get a bound statement,
+ which is passed to the provided action.
+ Note that by the time it is passed to the action, the query or command
+ has usually been executed.
+ A bound statement would normally be an instance of
+ <TT
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+></TT
+>, so it can be passed to
+ <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+>
+ in order to process the result-set, and also an instance of
+ <TT
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+></TT
+>, so that we can write
+ re-usable DML statements (inserts, updates, deletes).
+</P
+><P
+>The Typeable constraint is to prevent the leakage of marked things.
+ The type of bound statements should not be exported (and should not be
+ in Typeable) so the bound statement can't leak either.
+</P
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess =&gt; <A NAME="t%3AStatement"
+></A
+><B
+>Statement</B
+> stmt sess q | stmt sess -&gt; q</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="ndoc"
+><TT
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+></TT
+> defines the API for query objects i.e.
+ which types can be queries.
+</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Statement')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:Statement" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> BoundStmt <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> BoundStmt <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> BoundStmt <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> BoundStmt <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> PreparedStmtObj <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> PreparedStmtObj <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> PreparedStmtObj <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryString <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryString <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryString <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryString <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryString <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryStringTuned <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryStringTuned <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryStringTuned <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> StmtBind <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> StmtBind <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> String <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> String <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> String <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> String <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> (<A HREF="Database-Enumerator.html#t%3ARefCursor"
+>RefCursor</A
+> <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+>) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> (<A HREF="Database-Enumerator.html#t%3ARefCursor"
+>RefCursor</A
+> String) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> (<A HREF="Database-Enumerator.html#t%3ANextResultSet"
+>NextResultSet</A
+> mark PreparedStmtObj) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> (<A HREF="Database-Enumerator.html#t%3ANextResultSet"
+>NextResultSet</A
+> mark PreparedStmtObj) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess =&gt; <A NAME="t%3ACommand"
+></A
+><B
+>Command</B
+> stmt sess </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="ndoc"
+><TT
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+></TT
+> is not a query: command deletes or updates rows, creates/drops
+ tables, or changes database state.
+ <TT
+><A HREF="Database-InternalEnumerator.html#v%3AexecuteCommand"
+>executeCommand</A
+></TT
+> returns the number of affected rows (or 0 if DDL i.e. not DML).
+</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Command')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:Command" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> BoundStmt <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> BoundStmt <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> BoundStmt <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> BoundStmt <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> CommandBind <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> CommandBind <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> QueryString <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> QueryString <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> QueryString <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> QueryString <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> QueryString <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> QueryStringTuned <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> StmtBind <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> StmtBind <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> String <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> String <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> String <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> String <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess =&gt; <A NAME="t%3AEnvInquiry"
+></A
+><B
+>EnvInquiry</B
+> inquirykey sess result | inquirykey sess -&gt; result</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:EnvInquiry')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:EnvInquiry" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AEnvInquiry"
+>EnvInquiry</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ALastInsertRowid"
+>LastInsertRowid</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> Int64</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3APreparationA"
+></A
+><B
+>PreparationA</B
+> sess stmt</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="ndoc"
+><P
+>This type is not visible to the end user (cf. ConnectA). It forms a private
+ `communication channel' between Database.Enumerator and a back end.
+</P
+><P
+>Why don't we make a user-visible class with a <TT
+>prepare</TT
+> method?
+ Because it means to standardize the preparation method signature
+ across all databases. Some databases need more parameters, some
+ fewer. There may be several statement preparation functions within one
+ database.  So, instead of standardizing the signature of the
+ preparation function, we standardize on the _result_ of that
+ function. To be more precise, we standardize on the properties of the
+ result: whatever it is, the eventual prepared statement should be
+ suitable to be passed to <TT
+><A HREF="Database-InternalEnumerator.html#v%3AbindRun"
+>bindRun</A
+></TT
+>.
+</P
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess =&gt; <A NAME="t%3AIPrepared"
+></A
+><B
+>IPrepared</B
+> stmt sess bound_stmt bo | stmt -&gt; bound_stmt, stmt -&gt; bo</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:IPrepared')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:IPrepared" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIPrepared"
+>IPrepared</A
+> PreparedStmtObj <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> BoundStmt BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIPrepared"
+>IPrepared</A
+> PreparedStmtObj <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> BoundStmt BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIPrepared"
+>IPrepared</A
+> PreparedStmtObj <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> BoundStmt BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIPrepared"
+>IPrepared</A
+> PreparedStmtObj <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> BoundStmt BindObj</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ABindA"
+></A
+><B
+>BindA</B
+> sess stmt bo</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="ndoc"
+>The binding object (bo) below is very abstract, on purpose.
+ It may be |IO a|, it may be String, it may be a function, etc.
+ The binding object can hold the result of marshalling,
+ or bo can hold the current counter, etc.
+ Different databases do things very differently:
+ compare PostgreSQL and the Stub (which models Oracle).
+</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess =&gt; <A NAME="t%3ADBBind"
+></A
+><B
+>DBBind</B
+> a sess stmt bo | stmt -&gt; bo <SPAN CLASS="keyword"
+>where</SPAN
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="ndoc"
+>The class DBBind is not used by the end-user.
+ It is used to tie up low-level database access and the enumerator.
+ A database-specific library must provide a set of instances for DBBind.
+ The latter are the dual of DBType.
+</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+>Methods</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindP"
+></A
+><B
+>bindP</B
+> :: a -&gt; <A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> sess stmt bo</TD
+></TR
+><TR
+><TD CLASS="doc"
+>This is really just a wrapper that lets us write lists of
+ heterogenous bind values e.g. <TT
+>[bindP &quot;string&quot;, bindP (0::Int), ...]</TT
+>
+</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:DBBind')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:DBBind" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> a <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> a <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> a <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> a <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe CalendarTime) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe CalendarTime) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Double) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Double) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Double) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Double) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Float) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Int) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Int) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Int) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Int) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Int64) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Int64) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe String) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe String) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe String) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe String) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe UTCTime) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe UTCTime) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe UTCTime) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe UTCTime) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe Double)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe Double)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe Int)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe Int)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+>)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe String)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe String)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe UTCTime)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe UTCTime)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe a)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe a)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe a)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> a) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe a)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> a) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindP"
+></A
+><B
+>bindP</B
+> :: <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> a sess stmt bo =&gt; a -&gt; <A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> sess stmt bo</TD
+></TR
+><TR
+><TD CLASS="doc"
+>This is really just a wrapper that lets us write lists of
+ heterogenous bind values e.g. <TT
+>[bindP &quot;string&quot;, bindP (0::Int), ...]</TT
+>
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+><A NAME="10"
+>Iteratees and Cursors
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> sess =&gt; <A NAME="t%3AIQuery"
+></A
+><B
+>IQuery</B
+> q sess b | q -&gt; sess, q -&gt; b <SPAN CLASS="keyword"
+>where</SPAN
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="ndoc"
+><P
+>The class IQuery describes the class of query objects. Each
+ database (that is, each Session object) has its own Query object. 
+ We may assume that a Query object includes (at least, conceptually)
+ a (pointer to) a Session object, so a Query object determines the
+ Session object.
+ A back-end provides an instance (or instances) of IQuery.
+ The end user never seens the IQuery class (let alone its methods).
+</P
+><P
+>Can a session have several types of query objects?
+ Let's assume that it can: but a statement plus the session uniquely
+ determine the query,
+</P
+><P
+>Note that we explicitly use IO monad because we will have to explicitly
+ do FFI.
+</P
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+>Methods</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcurrentRowNum"
+></A
+><B
+>currentRowNum</B
+> :: q -&gt; IO Int</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:IQuery')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:IQuery" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> Query <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+> ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> Query <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> Query <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> Query <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> Query <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> ColumnBuffer</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AdoQuery"
+></A
+><B
+>doQuery</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: (<A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> stmt sess q, QueryIteratee (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess) q i seed b, <A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> q sess b)</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>=&gt; stmt</TD
+><TD CLASS="rdoc"
+>query
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; i</TD
+><TD CLASS="rdoc"
+>iteratee function
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; seed</TD
+><TD CLASS="rdoc"
+>seed value
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess seed</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="ndoc" COLSPAN="2"
+>The left-fold interface.
+</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A NAME="t%3ADBType"
+></A
+><B
+>DBType</B
+> a q b | q -&gt; b</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="ndoc"
+><P
+>A 'buffer' means a column buffer: a data structure that points to a
+ block of memory allocated for the values of one particular
+ column. Since a query normally fetches a row of several columns, we
+ typically deal with a list of column buffers. Although the column data
+ are typed (e.g., Integer, CalendarDate, etc), column buffers hide that
+ type. Think of the column buffer as Dynamics. The class DBType below
+ describes marshalling functions, to fetch a typed value out of the
+ 'untyped' columnBuffer.
+</P
+><P
+>Different DBMS's (that is, different session objects) have, in
+ general, columnBuffers of different types: the type of Column Buffer
+ is specific to a database.
+ So, ISession (m) uniquely determines the buffer type (b)??
+ Or, actually, a query uniquely determines the buffer.
+</P
+><P
+>The class DBType is not used by the end-user.
+ It is used to tie up low-level database access and the enumerator.
+ A database-specific library must provide a set of instances for DBType.
+</P
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:DBType')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:DBType" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe a) Query ColumnBuffer =&gt; <A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> a Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe a) Query ColumnBuffer =&gt; <A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> a Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe a) Query ColumnBuffer =&gt; <A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> a Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe a) Query ColumnBuffer =&gt; <A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> a Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe a) Query ColumnBuffer =&gt; <A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> a Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe CalendarTime) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe CalendarTime) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe CalendarTime) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe CalendarTime) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe Double) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe Double) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe Double) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe Double) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe Double) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe Float) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe Int) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe Int) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe Int) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe Int) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe Int) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe Int64) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe Int64) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe String) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe String) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe String) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe String) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe String) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe UTCTime) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe UTCTime) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe UTCTime) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe UTCTime) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+>(Show a, Read a) =&gt; <A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe a) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+>(Show a, Read a) =&gt; <A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe a) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+>(Show a, Read a) =&gt; <A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe a) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+>(Show a, Read a) =&gt; <A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe a) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+>(Show a, Read a) =&gt; <A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (Maybe a) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (<A HREF="Database-Enumerator.html#t%3ARefCursor"
+>RefCursor</A
+> <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+>) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (<A HREF="Database-Enumerator.html#t%3ARefCursor"
+>RefCursor</A
+> String) Query ColumnBuffer</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AIterResult"
+></A
+><B
+>IterResult</B
+> seedType = Either seedType seedType</TD
+></TR
+><TR
+><TD CLASS="doc"
+><TT
+><A HREF="Database-Enumerator.html#t%3AIterResult"
+>IterResult</A
+></TT
+> and <TT
+><A HREF="Database-Enumerator.html#t%3AIterAct"
+>IterAct</A
+></TT
+> give us some type sugar.
+ Without them, the types of iteratee functions become
+ quite unwieldy.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AIterAct"
+></A
+><B
+>IterAct</B
+> m seedType = seedType -&gt; m (<A HREF="Database-Enumerator.html#t%3AIterResult"
+>IterResult</A
+> seedType)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcurrentRowNum"
+></A
+><B
+>currentRowNum</B
+> :: <A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> q sess b =&gt; q -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ANextResultSet"
+></A
+><B
+>NextResultSet</B
+> mark stmt</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ANextResultSet"
+></A
+><B
+>NextResultSet</B
+> (<A HREF="Database-Enumerator.html#t%3APreparedStmt"
+>PreparedStmt</A
+> mark stmt)</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:NextResultSet')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:NextResultSet" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> (<A HREF="Database-Enumerator.html#t%3ANextResultSet"
+>NextResultSet</A
+> mark PreparedStmtObj) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> (<A HREF="Database-Enumerator.html#t%3ANextResultSet"
+>NextResultSet</A
+> mark PreparedStmtObj) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ARefCursor"
+></A
+><B
+>RefCursor</B
+> a</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ARefCursor"
+></A
+><B
+>RefCursor</B
+> a</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:RefCursor')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:RefCursor" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (<A HREF="Database-Enumerator.html#t%3ARefCursor"
+>RefCursor</A
+> <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+>) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>DBType</A
+> (<A HREF="Database-Enumerator.html#t%3ARefCursor"
+>RefCursor</A
+> String) Query ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> (<A HREF="Database-Enumerator.html#t%3ARefCursor"
+>RefCursor</A
+> <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+>) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> (<A HREF="Database-Enumerator.html#t%3ARefCursor"
+>RefCursor</A
+> String) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcursorIsEOF"
+></A
+><B
+>cursorIsEOF</B
+> :: DBCursor mark (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s) a -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s Bool</TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>cursorIsEOF's return value tells you if there are any more rows or not.
+ If you call <TT
+><A HREF="Database-Enumerator.html#v%3AcursorNext"
+>cursorNext</A
+></TT
+> when there are no more rows,
+ a DBNoData exception is thrown.
+ Cursors are automatically closed and freed when:
+</P
+><UL
+><LI
+> the iteratee returns <TT
+>Left a</TT
+>
+</LI
+><LI
+> the query result-set is exhausted.
+</LI
+></UL
+><P
+>To make life easier, we've created a <TT
+><A HREF="Database-Enumerator.html#v%3AwithCursor"
+>withCursor</A
+></TT
+> function,
+ which will clean up if an error (exception) occurs,
+ or the code exits early.
+ You can nest them to get interleaving, if you desire:
+</P
+><PRE
+>  withCursor query1 iter1 [] $ \c1 -&gt; do
+    withCursor query2 iter2 [] $ \c2 -&gt; do
+      r1 &lt;- cursorCurrent c1
+      r2 &lt;- cursorCurrent c2
+      ...
+      return something
+</PRE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcursorCurrent"
+></A
+><B
+>cursorCurrent</B
+> :: DBCursor mark (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s) a -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Returns the results fetched so far, processed by iteratee function.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcursorNext"
+></A
+><B
+>cursorNext</B
+> :: DBCursor mark (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s) a -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s (DBCursor mark (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark s) a)</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Advance the cursor. Returns the cursor. The return value is usually ignored.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AwithCursor"
+></A
+><B
+>withCursor</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: (Typeable a, <A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> stmt sess q, QueryIteratee (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess) q i seed b, <A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> q sess b)</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>=&gt; stmt</TD
+><TD CLASS="rdoc"
+>query
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; i</TD
+><TD CLASS="rdoc"
+>iteratee function
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; seed</TD
+><TD CLASS="rdoc"
+>seed value
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; (DBCursor mark (<A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess) seed -&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a)</TD
+><TD CLASS="rdoc"
+>action taking cursor parameter
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-Enumerator.html#t%3ADBM"
+>DBM</A
+> mark sess a</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="ndoc" COLSPAN="2"
+>Ensures cursor resource is properly tidied up in exceptional cases.
+ Propagates exceptions after closing cursor.
+ The Typeable constraint is to prevent cursors and other marked values
+ (like cursor computations) from escaping.
+</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3APosition"
+></A
+><B
+>Position</B
+> = Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+><A NAME="11"
+>Utilities
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AifNull"
+></A
+><B
+>ifNull</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: Maybe a</TD
+><TD CLASS="rdoc"
+>nullable value
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; a</TD
+><TD CLASS="rdoc"
+>value to substitute if first parameter is null i.e. <TT
+><A HREF="Data-Maybe.html#t%3ANothing"
+>Nothing</A
+></TT
+>
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; a</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="ndoc" COLSPAN="2"
+>Useful utility function, for SQL weenies.
+</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aresult"
+></A
+><B
+>result</B
+> :: Monad m =&gt; <A HREF="Database-Enumerator.html#t%3AIterAct"
+>IterAct</A
+> m a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Another useful utility function.
+ Use this to return a value from an iteratee function (the one passed to
+ <TT
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>doQuery</A
+></TT
+>).
+ Note that you should probably nearly always use the strict version.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aresult%27"
+></A
+><B
+>result'</B
+> :: Monad m =&gt; <A HREF="Database-Enumerator.html#t%3AIterAct"
+>IterAct</A
+> m a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>A strict version. This is recommended unless you have a specific need for laziness,
+ as the lazy version will gobble stack and heap.
+ If you have a large result-set (in the order of 10-100K rows or more),
+ it is likely to exhaust the standard 1M GHC stack.
+ Whether or not <TT
+><A HREF="Database-Enumerator.html#v%3Aresult"
+>result</A
+></TT
+> eats memory depends on what <TT
+>x</TT
+> does:
+ if it's a delayed computation then it almost certainly will.
+ This includes consing elements onto a list,
+ and arithmetic operations (counting, summing, etc).
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/Database-ODBC-Enumerator.html view
@@ -0,0 +1,655 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Database.ODBC.Enumerator</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Database.ODBC.Enumerator</FONT
+></TD
+><TD ALIGN="right"
+><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="infohead"
+>Portability</TD
+><TD CLASS="infoval"
+>non-portable</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Stability</TD
+><TD CLASS="infoval"
+>experimental</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Maintainer</TD
+><TD CLASS="infoval"
+>oleg@pobox.com, alistair@abayley.org</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Description</TD
+></TR
+><TR
+><TD CLASS="doc"
+>ODBC implementation of Database.Enumerator.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Documentation</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ASession"
+></A
+><B
+>Session</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Session')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:Session" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>Typeable <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> BoundStmt <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> QueryString <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> StmtBind <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> String <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> Query <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> BoundStmt <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> PreparedStmtObj <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryString <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> StmtBind <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> String <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> a <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIPrepared"
+>IPrepared</A
+> PreparedStmtObj <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> BoundStmt BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Double) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Int) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe String) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe UTCTime) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe Double)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe Int)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe String)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe UTCTime)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe a)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe a)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> a) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aconnect"
+></A
+><B
+>connect</B
+> :: String -&gt; <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareStmt"
+></A
+><B
+>prepareStmt</B
+> :: QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApreparePrefetch"
+></A
+><B
+>preparePrefetch</B
+> :: Int -&gt; QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareQuery"
+></A
+><B
+>prepareQuery</B
+> :: QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareLargeQuery"
+></A
+><B
+>prepareLargeQuery</B
+> :: Int -&gt; QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareCommand"
+></A
+><B
+>prepareCommand</B
+> :: QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Asql"
+></A
+><B
+>sql</B
+> :: String -&gt; QueryString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Asqlbind"
+></A
+><B
+>sqlbind</B
+> :: String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; StmtBind</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aprefetch"
+></A
+><B
+>prefetch</B
+> :: Int -&gt; String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; StmtBind</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Acmdbind"
+></A
+><B
+>cmdbind</B
+> :: String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; StmtBind</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>newtype</SPAN
+> <A NAME="t%3AOut"
+></A
+><B
+>Out</B
+> a</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AOut"
+></A
+><B
+>Out</B
+> a</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Out')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:Out" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe Double)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe Int)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe String)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe UTCTime)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe a)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe a)) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Out</A
+> a) <A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>module <A HREF="Database-Enumerator.html"
+>Database.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/Database-ODBC-OdbcFunctions.html view
@@ -0,0 +1,5679 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Database.ODBC.OdbcFunctions</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Database.ODBC.OdbcFunctions</FONT
+></TD
+><TD ALIGN="right"
+><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="infohead"
+>Portability</TD
+><TD CLASS="infoval"
+>non-portable</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Stability</TD
+><TD CLASS="infoval"
+>experimental</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Maintainer</TD
+><TD CLASS="infoval"
+>oleg@pobox.com, alistair@abayley.org</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Description</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Wrappers for ODBC FFI functions, plus buffer marshaling.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Synopsis</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AHandleObj"
+>HandleObj</A
+>  = <A HREF="#v%3AHandleObj"
+>HandleObj</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AHandle"
+>Handle</A
+> = Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandleObj"
+>HandleObj</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AEnvObj"
+>EnvObj</A
+>  = <A HREF="#v%3AEnvObj"
+>EnvObj</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AEnvHandle"
+>EnvHandle</A
+> = Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvObj"
+>EnvObj</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AConnObj"
+>ConnObj</A
+>  = <A HREF="#v%3AConnObj"
+>ConnObj</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AConnHdl"
+>ConnHdl</A
+> = Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnObj"
+>ConnObj</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AConnHandle"
+>ConnHandle</A
+>  = <A HREF="#v%3AConnHandle"
+>ConnHandle</A
+> {<TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="recfield"
+><A HREF="#v%3AconnHdl"
+>connHdl</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHdl"
+>ConnHdl</A
+></TD
+></TR
+><TR
+><TD CLASS="recfield"
+><A HREF="#v%3AconnDbms"
+>connDbms</A
+> :: String</TD
+></TR
+></TABLE
+>}</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AStmtObj"
+>StmtObj</A
+>  = <A HREF="#v%3AStmtObj"
+>StmtObj</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AStmtHdl"
+>StmtHdl</A
+> = Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtObj"
+>StmtObj</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AStmtHandle"
+>StmtHandle</A
+>  = <A HREF="#v%3AStmtHandle"
+>StmtHandle</A
+> {<TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="recfield"
+><A HREF="#v%3AstmtHdl"
+>stmtHdl</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+></TD
+></TR
+><TR
+><TD CLASS="recfield"
+><A HREF="#v%3AstmtDbms"
+>stmtDbms</A
+> :: String</TD
+></TR
+></TABLE
+>}</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AWindowHandle"
+>WindowHandle</A
+> = Ptr ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ABuffer"
+>Buffer</A
+>  = <A HREF="#v%3ABuffer"
+>Buffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ABufferFPtr"
+>BufferFPtr</A
+> = ForeignPtr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABuffer"
+>Buffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASizeFPtr"
+>SizeFPtr</A
+> = ForeignPtr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AMyCString"
+>MyCString</A
+> = CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AMyCStringLen"
+>MyCStringLen</A
+> = CStringLen</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ABindBuffer"
+>BindBuffer</A
+>  = <A HREF="#v%3ABindBuffer"
+>BindBuffer</A
+> {<TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="recfield"
+><A HREF="#v%3AbindBufPtr"
+>bindBufPtr</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+></TD
+></TR
+><TR
+><TD CLASS="recfield"
+><A HREF="#v%3AbindBufSzPtr"
+>bindBufSzPtr</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASizeFPtr"
+>SizeFPtr</A
+></TD
+></TR
+><TR
+><TD CLASS="recfield"
+><A HREF="#v%3AbindBufSize"
+>bindBufSize</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+></TD
+></TR
+></TABLE
+>}</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlInteger"
+>SqlInteger</A
+> = Int32</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlUInteger"
+>SqlUInteger</A
+> = Word32</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> = Int16</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+> = Word16</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlLen"
+>SqlLen</A
+> = Int32</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlULen"
+>SqlULen</A
+> = Word32</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlReturn"
+>SqlReturn</A
+> = <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlHandleType"
+>SqlHandleType</A
+> = <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlDataType"
+>SqlDataType</A
+> = <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlCDataType"
+>SqlCDataType</A
+> = <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> = <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqlInfoType"
+>SqlInfoType</A
+> = <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlDriverNoPrompt"
+>sqlDriverNoPrompt</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlNullTermedString"
+>sqlNullTermedString</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlNullData"
+>sqlNullData</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlTransCommit"
+>sqlTransCommit</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlTransRollback"
+>sqlTransRollback</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlAutoCommitOn"
+>sqlAutoCommitOn</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlAutoCommitOff"
+>sqlAutoCommitOff</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AOdbcException"
+>OdbcException</A
+>  = <A HREF="#v%3AOdbcException"
+>OdbcException</A
+> Int String String [<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcException"
+>OdbcException</A
+>]</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcatchOdbc"
+>catchOdbc</A
+> :: IO a -&gt; (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcException"
+>OdbcException</A
+> -&gt; IO a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AthrowOdbc"
+>throwOdbc</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcException"
+>OdbcException</A
+> -&gt; a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetDiagRec"
+>getDiagRec</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlHandleType"
+>SqlHandleType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; IO [<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcException"
+>OdbcException</A
+>]</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcheckError"
+>checkError</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlHandleType"
+>SqlHandleType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AallocHdl"
+>allocHdl</A
+> :: Storable a =&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlHandleType"
+>SqlHandleType</A
+> -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AallocEnv"
+>allocEnv</A
+> :: IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AallocConn"
+>allocConn</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AallocStmt"
+>allocStmt</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfreeHandle"
+>freeHandle</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlHandleType"
+>SqlHandleType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfreeEnv"
+>freeEnv</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfreeConn"
+>freeConn</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfreeStmt"
+>freeStmt</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aint2Ptr"
+>int2Ptr</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; Ptr ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsetOdbcVer"
+>setOdbcVer</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aconnect"
+>connect</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; String -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Adisconnect"
+>disconnect</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AprepareStmt"
+>prepareStmt</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; String -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AexecuteStmt"
+>executeStmt</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcloseCursor"
+>closeCursor</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ArowCount"
+>rowCount</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Afetch"
+>fetch</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO Bool</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmoreResults"
+>moreResults</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO Bool</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Acommit"
+>commit</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Arollback"
+>rollback</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsetAutoCommitOn"
+>setAutoCommitOn</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsetAutoCommitOff"
+>setAutoCommitOff</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsetTxnIsolation"
+>setTxnIsolation</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetInfoString"
+>getInfoString</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInfoType"
+>SqlInfoType</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetInfoDbmsName"
+>getInfoDbmsName</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetInfoDbmsVer"
+>getInfoDbmsVer</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetInfoDatabaseName"
+>getInfoDatabaseName</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetInfoDriverName"
+>getInfoDriverName</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetInfoDriverVer"
+>getInfoDriverVer</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetNativeSql"
+>getNativeSql</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; String -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetMaybeFromBuffer"
+>getMaybeFromBuffer</A
+> :: Storable a =&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; Ptr a -&gt; (Ptr a -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; IO b) -&gt; IO (Maybe b)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetDataStorable"
+>getDataStorable</A
+> :: Storable a =&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+> -&gt; Int -&gt; (a -&gt; b) -&gt; IO (Maybe b)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetDataUtcTime"
+>getDataUtcTime</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO (Maybe UTCTime)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetDataCStringLen"
+>getDataCStringLen</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO (Maybe CStringLen)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetDataUTF8String"
+>getDataUTF8String</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetDataCString"
+>getDataCString</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApeekSmallInt"
+>peekSmallInt</A
+> :: Ptr a -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApeekUSmallInt"
+>peekUSmallInt</A
+> :: Ptr a -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApeekUInteger"
+>peekUInteger</A
+> :: Ptr a -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUInteger"
+>SqlUInteger</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AreadUtcTimeFromMemory"
+>readUtcTimeFromMemory</A
+> :: Ptr Word8 -&gt; IO UTCTime</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindColumnBuffer"
+>bindColumnBuffer</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcreateEmptyBuffer"
+>createEmptyBuffer</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AtestForNull"
+>testForNull</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; (Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABuffer"
+>Buffer</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; IO a) -&gt; IO (Maybe a)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetStorableFromBuffer"
+>getStorableFromBuffer</A
+> :: Storable a =&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO (Maybe a)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetCAStringFromBuffer"
+>getCAStringFromBuffer</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetCWStringFromBuffer"
+>getCWStringFromBuffer</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetUTF8StringFromBuffer"
+>getUTF8StringFromBuffer</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetUtcTimeFromBuffer"
+>getUtcTimeFromBuffer</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO (Maybe UTCTime)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcreateBufferForStorable"
+>createBufferForStorable</A
+> :: Storable a =&gt; Maybe a -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcreateBufferHelper"
+>createBufferHelper</A
+> :: Storable a =&gt; a -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AwrapSizedBuffer"
+>wrapSizedBuffer</A
+> :: Ptr a -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindParam"
+>bindParam</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlCDataType"
+>SqlCDataType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlULen"
+>SqlULen</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindNull"
+>bindNull</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlCDataType"
+>SqlCDataType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindParamCStringLen"
+>bindParamCStringLen</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; Maybe CStringLen -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindEncodedString"
+>bindEncodedString</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; Maybe String -&gt; (String -&gt; ((Ptr a, Int) -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+>) -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+>) -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindParamUTF8String"
+>bindParamUTF8String</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; Maybe String -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindParamCAString"
+>bindParamCAString</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; Maybe String -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindParamCWString"
+>bindParamCWString</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; Maybe String -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApokeSmallInt"
+>pokeSmallInt</A
+> :: Ptr a -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApokeUSmallInt"
+>pokeUSmallInt</A
+> :: Ptr a -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApokeUInteger"
+>pokeUInteger</A
+> :: Ptr a -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUInteger"
+>SqlUInteger</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AwriteUTCTimeToMemory"
+>writeUTCTimeToMemory</A
+> :: Ptr Word8 -&gt; UTCTime -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmakeUtcTimeBuffer"
+>makeUtcTimeBuffer</A
+> :: UTCTime -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmakeUtcTimeStringBuffer"
+>makeUtcTimeStringBuffer</A
+> :: UTCTime -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindParamUtcTime"
+>bindParamUtcTime</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; Maybe UTCTime -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsizeOfMaybe"
+>sizeOfMaybe</A
+> :: <SPAN CLASS="keyword"
+>forall</SPAN
+> a . Storable a =&gt; Maybe a -&gt; Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>newtype</SPAN
+> <A HREF="#t%3AOutParam"
+>OutParam</A
+> a = <A HREF="#v%3AOutParam"
+>OutParam</A
+> a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>newtype</SPAN
+> <A HREF="#t%3AInOutParam"
+>InOutParam</A
+> a = <A HREF="#v%3AInOutParam"
+>InOutParam</A
+> a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="#t%3AOdbcBindBuffer"
+>OdbcBindBuffer</A
+> a  <SPAN CLASS="keyword"
+>where</SPAN
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindColBuffer"
+>bindColBuffer</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; Int -&gt; a -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetFromBuffer"
+>getFromBuffer</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetData"
+>getData</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO a</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> a  <SPAN CLASS="keyword"
+>where</SPAN
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindParamBuffer"
+>bindParamBuffer</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; a -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlAllocHandle"
+>sqlAllocHandle</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlHandleType"
+>SqlHandleType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlFreeHandle"
+>sqlFreeHandle</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlGetDiagRec"
+>sqlGetDiagRec</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlHandleType"
+>SqlHandleType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlDriverConnect"
+>sqlDriverConnect</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHdl"
+>ConnHdl</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AWindowHandle"
+>WindowHandle</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlDisconnect"
+>sqlDisconnect</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHdl"
+>ConnHdl</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlSetEnvAttr"
+>sqlSetEnvAttr</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; Ptr () -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlSetConnectAttr"
+>sqlSetConnectAttr</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHdl"
+>ConnHdl</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; Ptr () -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlPrepare"
+>sqlPrepare</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlBindParameter"
+>sqlBindParameter</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlCDataType"
+>SqlCDataType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlULen"
+>SqlULen</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABuffer"
+>Buffer</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlExecute"
+>sqlExecute</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlNumResultCols"
+>sqlNumResultCols</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlRowCount"
+>sqlRowCount</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlDescribeCol"
+>sqlDescribeCol</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlULen"
+>SqlULen</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlBindCol"
+>sqlBindCol</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABuffer"
+>Buffer</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlFetch"
+>sqlFetch</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlGetData"
+>sqlGetData</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABuffer"
+>Buffer</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlCloseCursor"
+>sqlCloseCursor</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlMoreResults"
+>sqlMoreResults</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlEndTran"
+>sqlEndTran</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlGetInfo"
+>sqlGetInfo</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHdl"
+>ConnHdl</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInfoType"
+>SqlInfoType</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABuffer"
+>Buffer</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlNativeSql"
+>sqlNativeSql</A
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHdl"
+>ConnHdl</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Documentation</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AHandleObj"
+></A
+><B
+>HandleObj</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AHandleObj"
+></A
+><B
+>HandleObj</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AHandle"
+></A
+><B
+>Handle</B
+> = Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandleObj"
+>HandleObj</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AEnvObj"
+></A
+><B
+>EnvObj</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AEnvObj"
+></A
+><B
+>EnvObj</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AEnvHandle"
+></A
+><B
+>EnvHandle</B
+> = Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvObj"
+>EnvObj</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AConnObj"
+></A
+><B
+>ConnObj</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AConnObj"
+></A
+><B
+>ConnObj</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AConnHdl"
+></A
+><B
+>ConnHdl</B
+> = Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnObj"
+>ConnObj</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AConnHandle"
+></A
+><B
+>ConnHandle</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="5" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AConnHandle"
+></A
+><B
+>ConnHandle</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="body" COLSPAN="2"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AconnHdl"
+></A
+><B
+>connHdl</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHdl"
+>ConnHdl</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AconnDbms"
+></A
+><B
+>connDbms</B
+> :: String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AStmtObj"
+></A
+><B
+>StmtObj</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AStmtObj"
+></A
+><B
+>StmtObj</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AStmtHdl"
+></A
+><B
+>StmtHdl</B
+> = Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtObj"
+>StmtObj</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AStmtHandle"
+></A
+><B
+>StmtHandle</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="5" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AStmtHandle"
+></A
+><B
+>StmtHandle</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="body" COLSPAN="2"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AstmtHdl"
+></A
+><B
+>stmtHdl</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AstmtDbms"
+></A
+><B
+>stmtDbms</B
+> :: String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AWindowHandle"
+></A
+><B
+>WindowHandle</B
+> = Ptr ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ABuffer"
+></A
+><B
+>Buffer</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ABuffer"
+></A
+><B
+>Buffer</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ABufferFPtr"
+></A
+><B
+>BufferFPtr</B
+> = ForeignPtr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABuffer"
+>Buffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASizeFPtr"
+></A
+><B
+>SizeFPtr</B
+> = ForeignPtr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AMyCString"
+></A
+><B
+>MyCString</B
+> = CString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AMyCStringLen"
+></A
+><B
+>MyCStringLen</B
+> = CStringLen</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ABindBuffer"
+></A
+><B
+>BindBuffer</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="5" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ABindBuffer"
+></A
+><B
+>BindBuffer</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="body" COLSPAN="2"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AbindBufPtr"
+></A
+><B
+>bindBufPtr</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AbindBufSzPtr"
+></A
+><B
+>bindBufSzPtr</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASizeFPtr"
+>SizeFPtr</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AbindBufSize"
+></A
+><B
+>bindBufSize</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlInteger"
+></A
+><B
+>SqlInteger</B
+> = Int32</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlUInteger"
+></A
+><B
+>SqlUInteger</B
+> = Word32</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlSmallInt"
+></A
+><B
+>SqlSmallInt</B
+> = Int16</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlUSmallInt"
+></A
+><B
+>SqlUSmallInt</B
+> = Word16</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlLen"
+></A
+><B
+>SqlLen</B
+> = Int32</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlULen"
+></A
+><B
+>SqlULen</B
+> = Word32</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlReturn"
+></A
+><B
+>SqlReturn</B
+> = <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlHandleType"
+></A
+><B
+>SqlHandleType</B
+> = <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlDataType"
+></A
+><B
+>SqlDataType</B
+> = <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlCDataType"
+></A
+><B
+>SqlCDataType</B
+> = <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlParamDirection"
+></A
+><B
+>SqlParamDirection</B
+> = <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqlInfoType"
+></A
+><B
+>SqlInfoType</B
+> = <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlDriverNoPrompt"
+></A
+><B
+>sqlDriverNoPrompt</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlNullTermedString"
+></A
+><B
+>sqlNullTermedString</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlNullData"
+></A
+><B
+>sqlNullData</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlTransCommit"
+></A
+><B
+>sqlTransCommit</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlTransRollback"
+></A
+><B
+>sqlTransRollback</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlAutoCommitOn"
+></A
+><B
+>sqlAutoCommitOn</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlAutoCommitOff"
+></A
+><B
+>sqlAutoCommitOff</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AOdbcException"
+></A
+><B
+>OdbcException</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AOdbcException"
+></A
+><B
+>OdbcException</B
+> Int String String [<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcException"
+>OdbcException</A
+>]</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:OdbcException')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:OdbcException" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+>Show <A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcException"
+>OdbcException</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>Typeable <A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcException"
+>OdbcException</A
+></TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcatchOdbc"
+></A
+><B
+>catchOdbc</B
+> :: IO a -&gt; (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcException"
+>OdbcException</A
+> -&gt; IO a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AthrowOdbc"
+></A
+><B
+>throwOdbc</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcException"
+>OdbcException</A
+> -&gt; a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetDiagRec"
+></A
+><B
+>getDiagRec</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlHandleType"
+>SqlHandleType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; IO [<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcException"
+>OdbcException</A
+>]</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcheckError"
+></A
+><B
+>checkError</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlHandleType"
+>SqlHandleType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AallocHdl"
+></A
+><B
+>allocHdl</B
+> :: Storable a =&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlHandleType"
+>SqlHandleType</A
+> -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AallocEnv"
+></A
+><B
+>allocEnv</B
+> :: IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AallocConn"
+></A
+><B
+>allocConn</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AallocStmt"
+></A
+><B
+>allocStmt</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfreeHandle"
+></A
+><B
+>freeHandle</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlHandleType"
+>SqlHandleType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfreeEnv"
+></A
+><B
+>freeEnv</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfreeConn"
+></A
+><B
+>freeConn</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfreeStmt"
+></A
+><B
+>freeStmt</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aint2Ptr"
+></A
+><B
+>int2Ptr</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; Ptr ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsetOdbcVer"
+></A
+><B
+>setOdbcVer</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aconnect"
+></A
+><B
+>connect</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; String -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Adisconnect"
+></A
+><B
+>disconnect</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareStmt"
+></A
+><B
+>prepareStmt</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; String -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AexecuteStmt"
+></A
+><B
+>executeStmt</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcloseCursor"
+></A
+><B
+>closeCursor</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ArowCount"
+></A
+><B
+>rowCount</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Afetch"
+></A
+><B
+>fetch</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO Bool</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Return True if there are more rows, False if end-of-data.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmoreResults"
+></A
+><B
+>moreResults</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO Bool</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Return True if there is another result-set to process.
+ Presumably the <TT
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+></TT
+> is modified to reference the
+ new result-set.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Acommit"
+></A
+><B
+>commit</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Arollback"
+></A
+><B
+>rollback</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsetAutoCommitOn"
+></A
+><B
+>setAutoCommitOn</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsetAutoCommitOff"
+></A
+><B
+>setAutoCommitOff</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsetTxnIsolation"
+></A
+><B
+>setTxnIsolation</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetInfoString"
+></A
+><B
+>getInfoString</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInfoType"
+>SqlInfoType</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetInfoDbmsName"
+></A
+><B
+>getInfoDbmsName</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetInfoDbmsVer"
+></A
+><B
+>getInfoDbmsVer</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetInfoDatabaseName"
+></A
+><B
+>getInfoDatabaseName</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetInfoDriverName"
+></A
+><B
+>getInfoDriverName</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetInfoDriverVer"
+></A
+><B
+>getInfoDriverVer</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetNativeSql"
+></A
+><B
+>getNativeSql</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; String -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetMaybeFromBuffer"
+></A
+><B
+>getMaybeFromBuffer</B
+> :: Storable a =&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; Ptr a -&gt; (Ptr a -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; IO b) -&gt; IO (Maybe b)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetDataStorable"
+></A
+><B
+>getDataStorable</B
+> :: Storable a =&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+> -&gt; Int -&gt; (a -&gt; b) -&gt; IO (Maybe b)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetDataUtcTime"
+></A
+><B
+>getDataUtcTime</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO (Maybe UTCTime)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetDataCStringLen"
+></A
+><B
+>getDataCStringLen</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO (Maybe CStringLen)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetDataUTF8String"
+></A
+><B
+>getDataUTF8String</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetDataCString"
+></A
+><B
+>getDataCString</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApeekSmallInt"
+></A
+><B
+>peekSmallInt</B
+> :: Ptr a -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApeekUSmallInt"
+></A
+><B
+>peekUSmallInt</B
+> :: Ptr a -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApeekUInteger"
+></A
+><B
+>peekUInteger</B
+> :: Ptr a -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUInteger"
+>SqlUInteger</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AreadUtcTimeFromMemory"
+></A
+><B
+>readUtcTimeFromMemory</B
+> :: Ptr Word8 -&gt; IO UTCTime</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindColumnBuffer"
+></A
+><B
+>bindColumnBuffer</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcreateEmptyBuffer"
+></A
+><B
+>createEmptyBuffer</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AtestForNull"
+></A
+><B
+>testForNull</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; (Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABuffer"
+>Buffer</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; IO a) -&gt; IO (Maybe a)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetStorableFromBuffer"
+></A
+><B
+>getStorableFromBuffer</B
+> :: Storable a =&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO (Maybe a)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetCAStringFromBuffer"
+></A
+><B
+>getCAStringFromBuffer</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetCWStringFromBuffer"
+></A
+><B
+>getCWStringFromBuffer</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetUTF8StringFromBuffer"
+></A
+><B
+>getUTF8StringFromBuffer</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetUtcTimeFromBuffer"
+></A
+><B
+>getUtcTimeFromBuffer</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO (Maybe UTCTime)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcreateBufferForStorable"
+></A
+><B
+>createBufferForStorable</B
+> :: Storable a =&gt; Maybe a -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcreateBufferHelper"
+></A
+><B
+>createBufferHelper</B
+> :: Storable a =&gt; a -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AwrapSizedBuffer"
+></A
+><B
+>wrapSizedBuffer</B
+> :: Ptr a -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindParam"
+></A
+><B
+>bindParam</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlCDataType"
+>SqlCDataType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlULen"
+>SqlULen</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindNull"
+></A
+><B
+>bindNull</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlCDataType"
+>SqlCDataType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindParamCStringLen"
+></A
+><B
+>bindParamCStringLen</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; Maybe CStringLen -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindEncodedString"
+></A
+><B
+>bindEncodedString</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; Maybe String -&gt; (String -&gt; ((Ptr a, Int) -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+>) -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+>) -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindParamUTF8String"
+></A
+><B
+>bindParamUTF8String</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; Maybe String -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindParamCAString"
+></A
+><B
+>bindParamCAString</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; Maybe String -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindParamCWString"
+></A
+><B
+>bindParamCWString</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; Maybe String -&gt; Int -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApokeSmallInt"
+></A
+><B
+>pokeSmallInt</B
+> :: Ptr a -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApokeUSmallInt"
+></A
+><B
+>pokeUSmallInt</B
+> :: Ptr a -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApokeUInteger"
+></A
+><B
+>pokeUInteger</B
+> :: Ptr a -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUInteger"
+>SqlUInteger</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AwriteUTCTimeToMemory"
+></A
+><B
+>writeUTCTimeToMemory</B
+> :: Ptr Word8 -&gt; UTCTime -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmakeUtcTimeBuffer"
+></A
+><B
+>makeUtcTimeBuffer</B
+> :: UTCTime -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmakeUtcTimeStringBuffer"
+></A
+><B
+>makeUtcTimeStringBuffer</B
+> :: UTCTime -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindParamUtcTime"
+></A
+><B
+>bindParamUtcTime</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+> -&gt; Maybe UTCTime -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsizeOfMaybe"
+></A
+><B
+>sizeOfMaybe</B
+> :: <SPAN CLASS="keyword"
+>forall</SPAN
+> a . Storable a =&gt; Maybe a -&gt; Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>newtype</SPAN
+> <A NAME="t%3AOutParam"
+></A
+><B
+>OutParam</B
+> a</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AOutParam"
+></A
+><B
+>OutParam</B
+> a</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:OutParam')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:OutParam" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOutParam"
+>OutParam</A
+> (Maybe Double))</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOutParam"
+>OutParam</A
+> (Maybe Int))</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOutParam"
+>OutParam</A
+> (Maybe String))</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOutParam"
+>OutParam</A
+> (Maybe UTCTime))</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>newtype</SPAN
+> <A NAME="t%3AInOutParam"
+></A
+><B
+>InOutParam</B
+> a</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AInOutParam"
+></A
+><B
+>InOutParam</B
+> a</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:InOutParam')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:InOutParam" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AInOutParam"
+>InOutParam</A
+> (Maybe Double))</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AInOutParam"
+>InOutParam</A
+> (Maybe Int))</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AInOutParam"
+>InOutParam</A
+> (Maybe String))</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AInOutParam"
+>InOutParam</A
+> (Maybe UTCTime))</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A NAME="t%3AOdbcBindBuffer"
+></A
+><B
+>OdbcBindBuffer</B
+> a  <SPAN CLASS="keyword"
+>where</SPAN
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+>Methods</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindColBuffer"
+></A
+><B
+>bindColBuffer</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+></TD
+><TD CLASS="rdoc"
+>stmt handle
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Int</TD
+><TD CLASS="rdoc"
+>column position (1-indexed)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Int</TD
+><TD CLASS="rdoc"
+>size of result buffer (ignored when it can be inferred from type of a)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; a</TD
+><TD CLASS="rdoc"
+>dummy value of the appropriate type (just to ensure we get the right class instance)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+><TD CLASS="rdoc"
+>returns a <TT
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TT
+> object
+</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetFromBuffer"
+></A
+><B
+>getFromBuffer</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetData"
+></A
+><B
+>getData</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO a</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:OdbcBindBuffer')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:OdbcBindBuffer" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindBuffer"
+>OdbcBindBuffer</A
+> (Maybe Double)</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindBuffer"
+>OdbcBindBuffer</A
+> (Maybe Int)</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindBuffer"
+>OdbcBindBuffer</A
+> (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindBuffer"
+>OdbcBindBuffer</A
+> (Maybe UTCTime)</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A NAME="t%3AOdbcBindParam"
+></A
+><B
+>OdbcBindParam</B
+> a  <SPAN CLASS="keyword"
+>where</SPAN
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+>Methods</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindParamBuffer"
+></A
+><B
+>bindParamBuffer</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+></TD
+><TD CLASS="rdoc"
+>stmt handle
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Int</TD
+><TD CLASS="rdoc"
+>parameter position (1-indexed)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; a</TD
+><TD CLASS="rdoc"
+>value to write to buffer
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Int</TD
+><TD CLASS="rdoc"
+>size of buffer, for output.
+ Value is ignored if input only (buffer will be sized to exactly hold input only)
+ or size is fixed by type (e.g. Int, Double)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+><TD CLASS="rdoc"
+>returns a <TT
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TT
+> object
+</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:OdbcBindParam')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:OdbcBindParam" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AInOutParam"
+>InOutParam</A
+> (Maybe Double))</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AInOutParam"
+>InOutParam</A
+> (Maybe Int))</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AInOutParam"
+>InOutParam</A
+> (Maybe String))</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AInOutParam"
+>InOutParam</A
+> (Maybe UTCTime))</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (Maybe Double)</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (Maybe Int)</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (Maybe UTCTime)</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOutParam"
+>OutParam</A
+> (Maybe Double))</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOutParam"
+>OutParam</A
+> (Maybe Int))</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOutParam"
+>OutParam</A
+> (Maybe String))</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>OdbcBindParam</A
+> (<A HREF="Database-ODBC-OdbcFunctions.html#t%3AOutParam"
+>OutParam</A
+> (Maybe UTCTime))</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlAllocHandle"
+></A
+><B
+>sqlAllocHandle</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlHandleType"
+>SqlHandleType</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlFreeHandle"
+></A
+><B
+>sqlFreeHandle</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlGetDiagRec"
+></A
+><B
+>sqlGetDiagRec</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlHandleType"
+>SqlHandleType</A
+></TD
+><TD CLASS="rdoc"
+>enum: which handle type is the next parameter?
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+></TD
+><TD CLASS="rdoc"
+>generic handle ptr
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>row (or message) number
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+></TD
+><TD CLASS="rdoc"
+>OUT: state
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+><TD CLASS="rdoc"
+>OUT: error number
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+></TD
+><TD CLASS="rdoc"
+>OUT: error message
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>IN: message buffer size
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>OUT: message length
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlDriverConnect"
+></A
+><B
+>sqlDriverConnect</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHdl"
+>ConnHdl</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AWindowHandle"
+>WindowHandle</A
+></TD
+><TD CLASS="rdoc"
+>just pass nullPtr
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+></TD
+><TD CLASS="rdoc"
+>connection string
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>connection string size
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+></TD
+><TD CLASS="rdoc"
+>OUT: buffer for normalised connection string
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>buffer size
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>OUT: length of returned string
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>enum: should driver prompt user for missing info?
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlDisconnect"
+></A
+><B
+>sqlDisconnect</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHdl"
+>ConnHdl</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlSetEnvAttr"
+></A
+><B
+>sqlSetEnvAttr</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+></TD
+><TD CLASS="rdoc"
+>Env Handle
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+><TD CLASS="rdoc"
+>Attribute (enumeration)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr ()</TD
+><TD CLASS="rdoc"
+>value (cast to void*)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+><TD CLASS="rdoc"
+>? - set to 0
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlSetConnectAttr"
+></A
+><B
+>sqlSetConnectAttr</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHdl"
+>ConnHdl</A
+></TD
+><TD CLASS="rdoc"
+>Connection Handle
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+><TD CLASS="rdoc"
+>Attribute (enumeration)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr ()</TD
+><TD CLASS="rdoc"
+>value (cast to void*)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+><TD CLASS="rdoc"
+>? - set to 0
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlPrepare"
+></A
+><B
+>sqlPrepare</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlBindParameter"
+></A
+><B
+>sqlBindParameter</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>position, 1-indexed
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>SqlParamDirection</A
+></TD
+><TD CLASS="rdoc"
+>direction: IN, OUT
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlCDataType"
+>SqlCDataType</A
+></TD
+><TD CLASS="rdoc"
+>C data type: char, int, long, float, etc
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+></TD
+><TD CLASS="rdoc"
+>SQL data type: string, int, long, date, etc
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlULen"
+>SqlULen</A
+></TD
+><TD CLASS="rdoc"
+>col size (precision)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>decimal digits (scale)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABuffer"
+>Buffer</A
+></TD
+><TD CLASS="rdoc"
+>input+output buffer
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+></TD
+><TD CLASS="rdoc"
+>buffer size
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+></TD
+><TD CLASS="rdoc"
+>input+output data size, or -1 (SQL_NULL_DATA) for null
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlExecute"
+></A
+><B
+>sqlExecute</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlNumResultCols"
+></A
+><B
+>sqlNumResultCols</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlRowCount"
+></A
+><B
+>sqlRowCount</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlDescribeCol"
+></A
+><B
+>sqlDescribeCol</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>position, 1-indexed
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+></TD
+><TD CLASS="rdoc"
+>buffer for column name
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>size of column name buffer
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>size of column name output string
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+></TD
+><TD CLASS="rdoc"
+>SQL data type: string, int, long, date, etc
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlULen"
+>SqlULen</A
+></TD
+><TD CLASS="rdoc"
+>col size (precision)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>decimal digits (scale)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>nullable: SQL_NO_NULLS, SQL_NULLABLE, or SQL_NULLABLE_UNKNOWN
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlBindCol"
+></A
+><B
+>sqlBindCol</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>column position, 1-indexed
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+></TD
+><TD CLASS="rdoc"
+>SQL data type: string, int, long, date, etc
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABuffer"
+>Buffer</A
+></TD
+><TD CLASS="rdoc"
+>output buffer
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+></TD
+><TD CLASS="rdoc"
+>output buffer size
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+></TD
+><TD CLASS="rdoc"
+>output data size, or -1 (SQL_NULL_DATA) for null
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlFetch"
+></A
+><B
+>sqlFetch</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlGetData"
+></A
+><B
+>sqlGetData</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>SqlUSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>column position, 1-indexed
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>SqlDataType</A
+></TD
+><TD CLASS="rdoc"
+>SQL data type: string, int, long, date, etc
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABuffer"
+>Buffer</A
+></TD
+><TD CLASS="rdoc"
+>output buffer
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+></TD
+><TD CLASS="rdoc"
+>output buffer size
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>SqlLen</A
+></TD
+><TD CLASS="rdoc"
+>output data size, or -1 (SQL_NULL_DATA) for null
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlCloseCursor"
+></A
+><B
+>sqlCloseCursor</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlMoreResults"
+></A
+><B
+>sqlMoreResults</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>StmtHdl</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlEndTran"
+></A
+><B
+>sqlEndTran</B
+> :: <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Handle</A
+> -&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+> -&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlGetInfo"
+></A
+><B
+>sqlGetInfo</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHdl"
+>ConnHdl</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInfoType"
+>SqlInfoType</A
+></TD
+><TD CLASS="rdoc"
+>information type
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ABuffer"
+>Buffer</A
+></TD
+><TD CLASS="rdoc"
+>output buffer
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>output buffer size
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>SqlSmallInt</A
+></TD
+><TD CLASS="rdoc"
+>output data size, or -1 (SQL_NULL_DATA) for null
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlNativeSql"
+></A
+><B
+>sqlNativeSql</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHdl"
+>ConnHdl</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+></TD
+><TD CLASS="rdoc"
+>sql text in
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+><TD CLASS="rdoc"
+>size of sql text
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>MyCString</A
+></TD
+><TD CLASS="rdoc"
+>buffer for output text
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+><TD CLASS="rdoc"
+>size of output buffer
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Ptr <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>SqlInteger</A
+></TD
+><TD CLASS="rdoc"
+>size of text in output buffer
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>SqlReturn</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/Database-Oracle-Enumerator.html view
@@ -0,0 +1,966 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Database.Oracle.Enumerator</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Database.Oracle.Enumerator</FONT
+></TD
+><TD ALIGN="right"
+><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="infohead"
+>Portability</TD
+><TD CLASS="infoval"
+>non-portable</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Stability</TD
+><TD CLASS="infoval"
+>experimental</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Maintainer</TD
+><TD CLASS="infoval"
+>oleg@pobox.com, alistair@abayley.org</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Description</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Oracle OCI implementation of Database.Enumerator.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Synopsis</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ASession"
+>Session</A
+> </TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aconnect"
+>connect</A
+> :: String -&gt; String -&gt; String -&gt; <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AprepareStmt"
+>prepareStmt</A
+> :: QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApreparePrefetch"
+>preparePrefetch</A
+> :: Int -&gt; QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AprepareQuery"
+>prepareQuery</A
+> :: QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AprepareLargeQuery"
+>prepareLargeQuery</A
+> :: Int -&gt; QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AprepareCommand"
+>prepareCommand</A
+> :: QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AprepareLargeCommand"
+>prepareLargeCommand</A
+> :: Int -&gt; QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Asql"
+>sql</A
+> :: String -&gt; QueryString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Asqlbind"
+>sqlbind</A
+> :: String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; QueryStringTuned</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aprefetch"
+>prefetch</A
+> :: Int -&gt; String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; QueryStringTuned</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Acmdbind"
+>cmdbind</A
+> :: String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; CommandBind</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AStmtHandle"
+>StmtHandle</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtStruct"
+>StmtStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>newtype</SPAN
+> <A HREF="#t%3AOut"
+>Out</A
+> a = <A HREF="#v%3AOut"
+>Out</A
+> a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>module <A HREF="Database-Enumerator.html"
+>Database.Enumerator</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Documentation</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ASession"
+></A
+><B
+>Session</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Session')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:Session" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>Typeable <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> BoundStmt <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> CommandBind <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> QueryString <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> String <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> Query <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> BoundStmt <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> PreparedStmtObj <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryString <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryStringTuned <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> String <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> a <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIPrepared"
+>IPrepared</A
+> PreparedStmtObj <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> BoundStmt BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> (<A HREF="Database-Enumerator.html#t%3ARefCursor"
+>RefCursor</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3AStmtHandle"
+>StmtHandle</A
+>) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe CalendarTime) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Double) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Int) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe String) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe UTCTime) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe Double)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe Int)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe <A HREF="Database-Oracle-Enumerator.html#t%3AStmtHandle"
+>StmtHandle</A
+>)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe String)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe UTCTime)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe a)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe a)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> a) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> (<A HREF="Database-Enumerator.html#t%3ANextResultSet"
+>NextResultSet</A
+> mark PreparedStmtObj) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aconnect"
+></A
+><B
+>connect</B
+> :: String -&gt; String -&gt; String -&gt; <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareStmt"
+></A
+><B
+>prepareStmt</B
+> :: QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApreparePrefetch"
+></A
+><B
+>preparePrefetch</B
+> :: Int -&gt; QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareQuery"
+></A
+><B
+>prepareQuery</B
+> :: QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareLargeQuery"
+></A
+><B
+>prepareLargeQuery</B
+> :: Int -&gt; QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareCommand"
+></A
+><B
+>prepareCommand</B
+> :: QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareLargeCommand"
+></A
+><B
+>prepareLargeCommand</B
+> :: Int -&gt; QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Seems like an odd alternative to <TT
+><A HREF="Database-Oracle-Enumerator.html#v%3AprepareCommand"
+>prepareCommand</A
+></TT
+> (what is a large command?)
+ but is actually useful for when the outer query it a procedure call that
+ returns one or more cursors. The prefetch count for the inner cursors is
+ inherited from the outer statement, which in this case is a command, rather
+ than a select. Normally prefetch would be irrelevant (and indeed it is for
+ the outer command), but we also save it in the statement so that it can be
+ reused for the child cursors.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Asql"
+></A
+><B
+>sql</B
+> :: String -&gt; QueryString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Asqlbind"
+></A
+><B
+>sqlbind</B
+> :: String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; QueryStringTuned</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aprefetch"
+></A
+><B
+>prefetch</B
+> :: Int -&gt; String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; QueryStringTuned</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Acmdbind"
+></A
+><B
+>cmdbind</B
+> :: String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; CommandBind</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AStmtHandle"
+></A
+><B
+>StmtHandle</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtStruct"
+>StmtStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>newtype</SPAN
+> <A NAME="t%3AOut"
+></A
+><B
+>Out</B
+> a</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AOut"
+></A
+><B
+>Out</B
+> a</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Out')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:Out" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe Double)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe Int)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe <A HREF="Database-Oracle-Enumerator.html#t%3AStmtHandle"
+>StmtHandle</A
+>)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe String)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe UTCTime)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe a)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> (Maybe a)) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (<A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Out</A
+> a) <A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>module <A HREF="Database-Enumerator.html"
+>Database.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/Database-Oracle-OCIConstants.html view
@@ -0,0 +1,1059 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Database.Oracle.OCIConstants</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Database.Oracle.OCIConstants</FONT
+></TD
+><TD ALIGN="right"
+><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="infohead"
+>Portability</TD
+><TD CLASS="infoval"
+>non-portable</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Stability</TD
+><TD CLASS="infoval"
+>experimental</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Maintainer</TD
+><TD CLASS="infoval"
+>oleg@pobox.com, alistair@abayley.org</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+><B
+>Contents</B
+></TD
+></TR
+><TR
+><TD
+><DL
+><DT
+><A HREF="#1"
+>Used all over the place:
+</A
+></DT
+><DT
+><A HREF="#2"
+>Handle types:
+</A
+></DT
+><DT
+><A HREF="#3"
+>Error code types:
+</A
+></DT
+><DT
+><A HREF="#4"
+>Attribute types:
+</A
+></DT
+><DT
+><A HREF="#5"
+>Authentication options:
+</A
+></DT
+><DT
+><A HREF="#6"
+>Syntax types (i.e. does the DBMS understand v7 or v8 syntax, etc):
+</A
+></DT
+><DT
+><A HREF="#7"
+>Scrollable Cursor Options:
+</A
+></DT
+><DT
+><A HREF="#8"
+>OCI datatypes:
+</A
+></DT
+><DT
+><A HREF="#9"
+>Transaction types; parameters for ociTransStart.
+</A
+></DT
+></DL
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Description</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Contains CInt equivalents of the #defines in the oci library headers.
+ This is not a complete set; just enough to get the Haskell libraries working.
+ This also might not be particularly portable, but I don't think Oracle are going
+ to change these in a hurry (that would break compiled programs, wouldn't it?).
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Synopsis</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_DEFAULT"
+>oci_DEFAULT</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_CRED_RDBMS"
+>oci_CRED_RDBMS</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_CRED_EXT"
+>oci_CRED_EXT</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_CRED_PROXY"
+>oci_CRED_PROXY</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_NTV_SYNTAX"
+>oci_NTV_SYNTAX</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_FETCH_NEXT"
+>oci_FETCH_NEXT</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_FETCH_FIRST"
+>oci_FETCH_FIRST</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_FETCH_LAST"
+>oci_FETCH_LAST</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_FETCH_PRIOR"
+>oci_FETCH_PRIOR</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_FETCH_ABSOLUTE"
+>oci_FETCH_ABSOLUTE</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_FETCH_RELATIVE"
+>oci_FETCH_RELATIVE</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_FETCH_RESERVED"
+>oci_FETCH_RESERVED</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_CHR"
+>oci_SQLT_CHR</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_NUM"
+>oci_SQLT_NUM</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_INT"
+>oci_SQLT_INT</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_FLT"
+>oci_SQLT_FLT</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_STR"
+>oci_SQLT_STR</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_VNU"
+>oci_SQLT_VNU</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_LNG"
+>oci_SQLT_LNG</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_VCS"
+>oci_SQLT_VCS</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_RID"
+>oci_SQLT_RID</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_DAT"
+>oci_SQLT_DAT</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_VBI"
+>oci_SQLT_VBI</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_BIN"
+>oci_SQLT_BIN</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_LBI"
+>oci_SQLT_LBI</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_UIN"
+>oci_SQLT_UIN</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_LVC"
+>oci_SQLT_LVC</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_LVB"
+>oci_SQLT_LVB</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_AFC"
+>oci_SQLT_AFC</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_AVC"
+>oci_SQLT_AVC</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_SQLT_RSET"
+>oci_SQLT_RSET</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_TRANS_READONLY"
+>oci_TRANS_READONLY</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_TRANS_READWRITE"
+>oci_TRANS_READWRITE</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aoci_TRANS_SERIALIZABLE"
+>oci_TRANS_SERIALIZABLE</A
+> :: CInt</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="1"
+>Used all over the place:
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_DEFAULT"
+></A
+><B
+>oci_DEFAULT</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="2"
+>Handle types:
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="3"
+>Error code types:
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="4"
+>Attribute types:
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="5"
+>Authentication options:
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_CRED_RDBMS"
+></A
+><B
+>oci_CRED_RDBMS</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Found in $ORAHOME/oci/include/oci.h
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_CRED_EXT"
+></A
+><B
+>oci_CRED_EXT</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_CRED_PROXY"
+></A
+><B
+>oci_CRED_PROXY</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="6"
+>Syntax types (i.e. does the DBMS understand v7 or v8 syntax, etc):
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_NTV_SYNTAX"
+></A
+><B
+>oci_NTV_SYNTAX</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Found in $ORAHOME/oci/include/oci.h
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="7"
+>Scrollable Cursor Options:
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_FETCH_NEXT"
+></A
+><B
+>oci_FETCH_NEXT</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Found in $ORAHOME/oci/include/oci.h
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_FETCH_FIRST"
+></A
+><B
+>oci_FETCH_FIRST</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_FETCH_LAST"
+></A
+><B
+>oci_FETCH_LAST</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_FETCH_PRIOR"
+></A
+><B
+>oci_FETCH_PRIOR</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_FETCH_ABSOLUTE"
+></A
+><B
+>oci_FETCH_ABSOLUTE</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_FETCH_RELATIVE"
+></A
+><B
+>oci_FETCH_RELATIVE</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_FETCH_RESERVED"
+></A
+><B
+>oci_FETCH_RESERVED</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="8"
+>OCI datatypes:
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_CHR"
+></A
+><B
+>oci_SQLT_CHR</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Found in $ORAHOME/oci/include/ocidfn.h
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_NUM"
+></A
+><B
+>oci_SQLT_NUM</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_INT"
+></A
+><B
+>oci_SQLT_INT</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_FLT"
+></A
+><B
+>oci_SQLT_FLT</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_STR"
+></A
+><B
+>oci_SQLT_STR</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_VNU"
+></A
+><B
+>oci_SQLT_VNU</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_LNG"
+></A
+><B
+>oci_SQLT_LNG</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_VCS"
+></A
+><B
+>oci_SQLT_VCS</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_RID"
+></A
+><B
+>oci_SQLT_RID</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_DAT"
+></A
+><B
+>oci_SQLT_DAT</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_VBI"
+></A
+><B
+>oci_SQLT_VBI</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_BIN"
+></A
+><B
+>oci_SQLT_BIN</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_LBI"
+></A
+><B
+>oci_SQLT_LBI</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_UIN"
+></A
+><B
+>oci_SQLT_UIN</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_LVC"
+></A
+><B
+>oci_SQLT_LVC</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_LVB"
+></A
+><B
+>oci_SQLT_LVB</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_AFC"
+></A
+><B
+>oci_SQLT_AFC</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_AVC"
+></A
+><B
+>oci_SQLT_AVC</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_SQLT_RSET"
+></A
+><B
+>oci_SQLT_RSET</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section2"
+><A NAME="9"
+>Transaction types; parameters for ociTransStart.
+</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_TRANS_READONLY"
+></A
+><B
+>oci_TRANS_READONLY</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Found in $ORAHOME/oci/include/oci.h.
+ There are more than this, but they're related to complicated
+ transaction-management stuff in the OCI libraries that I don't understand.
+ These should be sufficient to support the simple transaction model
+ understood by most developers.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_TRANS_READWRITE"
+></A
+><B
+>oci_TRANS_READWRITE</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aoci_TRANS_SERIALIZABLE"
+></A
+><B
+>oci_TRANS_SERIALIZABLE</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/Database-Oracle-OCIFunctions.html view
@@ -0,0 +1,4524 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Database.Oracle.OCIFunctions</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Database.Oracle.OCIFunctions</FONT
+></TD
+><TD ALIGN="right"
+><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="infohead"
+>Portability</TD
+><TD CLASS="infoval"
+>non-portable</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Stability</TD
+><TD CLASS="infoval"
+>experimental</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Maintainer</TD
+><TD CLASS="infoval"
+>oleg@pobox.com, alistair@abayley.org</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Description</TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>Simple wrappers for OCI functions (FFI).
+</P
+><P
+>The functions in this file are simple wrappers for OCI functions.
+ The wrappers add error detection and exceptions;
+ functions in this module raise <TT
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+></TT
+>.
+ The next layer up traps these and turns them into <TT
+><A HREF="Database-Enumerator.html#t%3ADBException"
+>DBException</A
+></TT
+>.
+</P
+><P
+>Note that <TT
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+></TT
+> <EM
+>does not</EM
+> contain the error number and text
+ returned by <TT
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AgetOCIErrorMsg"
+>getOCIErrorMsg</A
+></TT
+>.
+ It is the job of the next layer (module) up to catch the <TT
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+></TT
+>
+ and then call <TT
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AgetOCIErrorMsg"
+>getOCIErrorMsg</A
+></TT
+> to get the actual error details.
+ The <TT
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+></TT
+> simply contains the error number returned by
+ the OCI call, and some text identifying the wrapper function.
+ See <TT
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AformatErrorCodeDesc"
+>formatErrorCodeDesc</A
+></TT
+> for the set of possible values for the OCI error numbers.
+</P
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Synopsis</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AOCIStruct"
+>OCIStruct</A
+>  = <A HREF="#v%3AOCIStruct"
+>OCIStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AOCIHandle"
+>OCIHandle</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIStruct"
+>OCIStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AOCIBuffer"
+>OCIBuffer</A
+>  = <A HREF="#v%3AOCIBuffer"
+>OCIBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ABufferPtr"
+>BufferPtr</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIBuffer"
+>OCIBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ABufferFPtr"
+>BufferFPtr</A
+> = ForeignPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIBuffer"
+>OCIBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AColumnResultBuffer"
+>ColumnResultBuffer</A
+> = ForeignPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIBuffer"
+>OCIBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ABindBuffer"
+>BindBuffer</A
+> = (ForeignPtr CShort, ForeignPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIBuffer"
+>OCIBuffer</A
+>, ForeignPtr CUShort)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AContext"
+>Context</A
+>  = <A HREF="#v%3AContext"
+>Context</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AContextPtr"
+>ContextPtr</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AContext"
+>Context</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AEnvStruct"
+>EnvStruct</A
+>  = <A HREF="#v%3AEnvStruct"
+>EnvStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AEnvHandle"
+>EnvHandle</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvStruct"
+>EnvStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AErrorStruct"
+>ErrorStruct</A
+>  = <A HREF="#v%3AErrorStruct"
+>ErrorStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AErrorHandle"
+>ErrorHandle</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorStruct"
+>ErrorStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AServerStruct"
+>ServerStruct</A
+>  = <A HREF="#v%3AServerStruct"
+>ServerStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AServerHandle"
+>ServerHandle</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AServerStruct"
+>ServerStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AUserStruct"
+>UserStruct</A
+>  = <A HREF="#v%3AUserStruct"
+>UserStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AUserHandle"
+>UserHandle</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AUserStruct"
+>UserStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AConnStruct"
+>ConnStruct</A
+>  = <A HREF="#v%3AConnStruct"
+>ConnStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AConnHandle"
+>ConnHandle</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnStruct"
+>ConnStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ASessStruct"
+>SessStruct</A
+>  = <A HREF="#v%3ASessStruct"
+>SessStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASessHandle"
+>SessHandle</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ASessStruct"
+>SessStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AStmtStruct"
+>StmtStruct</A
+>  = <A HREF="#v%3AStmtStruct"
+>StmtStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AStmtHandle"
+>StmtHandle</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtStruct"
+>StmtStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ADefnStruct"
+>DefnStruct</A
+>  = <A HREF="#v%3ADefnStruct"
+>DefnStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ADefnHandle"
+>DefnHandle</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ADefnStruct"
+>DefnStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AParamStruct"
+>ParamStruct</A
+>  = <A HREF="#v%3AParamStruct"
+>ParamStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AParamHandle"
+>ParamHandle</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AParamStruct"
+>ParamStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ABindStruct"
+>BindStruct</A
+>  = <A HREF="#v%3ABindStruct"
+>BindStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ABindHandle"
+>BindHandle</A
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindStruct"
+>BindStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AColumnInfo"
+>ColumnInfo</A
+> = (<A HREF="Database-Oracle-OCIFunctions.html#t%3ADefnHandle"
+>DefnHandle</A
+>, <A HREF="Database-Oracle-OCIFunctions.html#t%3AColumnResultBuffer"
+>ColumnResultBuffer</A
+>, ForeignPtr CShort, ForeignPtr CUShort)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AOCIException"
+>OCIException</A
+>  = <A HREF="#v%3AOCIException"
+>OCIException</A
+> CInt String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcatchOCI"
+>catchOCI</A
+> :: IO a -&gt; (<A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+> -&gt; IO a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AthrowOCI"
+>throwOCI</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+> -&gt; a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmkCInt"
+>mkCInt</A
+> :: Int -&gt; CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmkCShort"
+>mkCShort</A
+> :: CInt -&gt; CShort</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmkCUShort"
+>mkCUShort</A
+> :: CInt -&gt; CUShort</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcStrLen"
+>cStrLen</A
+> :: CStringLen -&gt; CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcStr"
+>cStr</A
+> :: CStringLen -&gt; CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociEnvCreate"
+>ociEnvCreate</A
+> :: Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; CInt -&gt; Ptr a -&gt; FunPtr a -&gt; FunPtr a -&gt; FunPtr a -&gt; CInt -&gt; Ptr (Ptr a) -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociHandleAlloc"
+>ociHandleAlloc</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; CInt -&gt; Ptr a -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociHandleFree"
+>ociHandleFree</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociErrorGet"
+>ociErrorGet</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; CString -&gt; Ptr CInt -&gt; CString -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociParamGet"
+>ociParamGet</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociAttrGet"
+>ociAttrGet</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; Ptr CInt -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociAttrSet"
+>ociAttrSet</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; CInt -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociLogon"
+>ociLogon</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; CString -&gt; CInt -&gt; CString -&gt; CInt -&gt; CString -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociLogoff"
+>ociLogoff</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociSessionBegin"
+>ociSessionBegin</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ASessHandle"
+>SessHandle</A
+> -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociSessionEnd"
+>ociSessionEnd</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ASessHandle"
+>SessHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociServerAttach"
+>ociServerAttach</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AServerHandle"
+>ServerHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CString -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociServerDetach"
+>ociServerDetach</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AServerHandle"
+>ServerHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociTerminate"
+>ociTerminate</A
+> :: CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociTransStart"
+>ociTransStart</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; Word8 -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociTransCommit"
+>ociTransCommit</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociTransRollback"
+>ociTransRollback</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociStmtPrepare"
+>ociStmtPrepare</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CString -&gt; CInt -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociDefineByPos"
+>ociDefineByPos</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ADefnHandle"
+>DefnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; CInt -&gt; CUShort -&gt; Ptr CShort -&gt; Ptr CUShort -&gt; Ptr CUShort -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociStmtExecute"
+>ociStmtExecute</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CInt -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociStmtFetch"
+>ociStmtFetch</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CInt -&gt; CShort -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociBindByPos"
+>ociBindByPos</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindHandle"
+>BindHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CUInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; CInt -&gt; CUShort -&gt; Ptr CShort -&gt; Ptr CUShort -&gt; Ptr CUShort -&gt; CUInt -&gt; Ptr CUInt -&gt; CUInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AociBindDynamic"
+>ociBindDynamic</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindHandle"
+>BindHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AContextPtr"
+>ContextPtr</A
+> -&gt; FunPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackInBind"
+>OCICallbackInBind</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AContextPtr"
+>ContextPtr</A
+> -&gt; FunPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackOutBind"
+>OCICallbackOutBind</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AOCICallbackInBind"
+>OCICallbackInBind</A
+> = <A HREF="Database-Oracle-OCIFunctions.html#t%3AContextPtr"
+>ContextPtr</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindHandle"
+>BindHandle</A
+> -&gt; CInt -&gt; CInt -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; CInt -&gt; Ptr Word8 -&gt; Ptr CShort -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AOCICallbackOutBind"
+>OCICallbackOutBind</A
+> = <A HREF="Database-Oracle-OCIFunctions.html#t%3AContextPtr"
+>ContextPtr</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindHandle"
+>BindHandle</A
+> -&gt; CInt -&gt; CInt -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; Ptr CInt -&gt; Ptr Word8 -&gt; Ptr CShort -&gt; Ptr (Ptr CShort) -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmkOCICallbackInBind"
+>mkOCICallbackInBind</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackInBind"
+>OCICallbackInBind</A
+> -&gt; IO (FunPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackInBind"
+>OCICallbackInBind</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmkOCICallbackOutBind"
+>mkOCICallbackOutBind</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackOutBind"
+>OCICallbackOutBind</A
+> -&gt; IO (FunPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackOutBind"
+>OCICallbackOutBind</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetOCIErrorMsg2"
+>getOCIErrorMsg2</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; Ptr CInt -&gt; CString -&gt; CInt -&gt; IO (CInt, String)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetOCIErrorMsg"
+>getOCIErrorMsg</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; IO (CInt, String)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfromEnumOCIErrorCode"
+>fromEnumOCIErrorCode</A
+> :: CInt -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AformatErrorCodeDesc"
+>formatErrorCodeDesc</A
+> :: CInt -&gt; String -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AformatOCIMsg"
+>formatOCIMsg</A
+> :: CInt -&gt; String -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; IO (Int, String)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AformatMsgCommon"
+>formatMsgCommon</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; IO (Int, String)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AformatErrorMsg"
+>formatErrorMsg</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; IO (Int, String)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AformatEnvMsg"
+>formatEnvMsg</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; IO (Int, String)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AtestForError"
+>testForError</A
+> :: CInt -&gt; String -&gt; a -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AtestForErrorWithPtr"
+>testForErrorWithPtr</A
+> :: Storable a =&gt; CInt -&gt; String -&gt; Ptr a -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AenvCreate"
+>envCreate</A
+> :: IO <A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AhandleAlloc"
+>handleAlloc</A
+> :: CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AhandleFree"
+>handleFree</A
+> :: CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsetHandleAttr"
+>setHandleAttr</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; Ptr a -&gt; CInt -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsetHandleAttrString"
+>setHandleAttrString</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; String -&gt; CInt -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetHandleAttr"
+>getHandleAttr</A
+> :: Storable a =&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; CInt -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetParam"
+>getParam</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3AParamHandle"
+>ParamHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AdbLogon"
+>dbLogon</A
+> :: String -&gt; String -&gt; String -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AdbLogoff"
+>dbLogoff</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aterminate"
+>terminate</A
+> :: IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AserverDetach"
+>serverDetach</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AServerHandle"
+>ServerHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AserverAttach"
+>serverAttach</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AServerHandle"
+>ServerHandle</A
+> -&gt; String -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetSession"
+>getSession</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3ASessHandle"
+>SessHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsessionBegin"
+>sessionBegin</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ASessHandle"
+>SessHandle</A
+> -&gt; CInt -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsessionEnd"
+>sessionEnd</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ASessHandle"
+>SessHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbeginTrans"
+>beginTrans</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; CInt -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcommitTrans"
+>commitTrans</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ArollbackTrans"
+>rollbackTrans</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtPrepare"
+>stmtPrepare</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; String -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtExecute"
+>stmtExecute</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AdefineByPos"
+>defineByPos</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; Int -&gt; CInt -&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3AColumnInfo"
+>ColumnInfo</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Asbph"
+>sbph</A
+> :: String -&gt; Int -&gt; Bool -&gt; String -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindByPos"
+>bindByPos</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; Int -&gt; CInt -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindOutputByPos"
+>bindOutputByPos</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+> -&gt; Int -&gt; CInt -&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindHandle"
+>BindHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtFetch"
+>stmtFetch</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmaybeBufferNull"
+>maybeBufferNull</A
+> :: ForeignPtr CShort -&gt; Maybe a -&gt; IO a -&gt; IO (Maybe a)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AnullByte"
+>nullByte</A
+> :: CChar</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcShort2Int"
+>cShort2Int</A
+> :: CShort -&gt; Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcUShort2Int"
+>cUShort2Int</A
+> :: CUShort -&gt; Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcuCharToInt"
+>cuCharToInt</A
+> :: CUChar -&gt; Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbyteToInt"
+>byteToInt</A
+> :: Ptr CUChar -&gt; Int -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbufferToString"
+>bufferToString</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AColumnInfo"
+>ColumnInfo</A
+> -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmakeYear"
+>makeYear</A
+> :: Int -&gt; Int -&gt; Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmakeYearByte"
+>makeYearByte</A
+> :: Int -&gt; Word8</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmakeCentByte"
+>makeCentByte</A
+> :: Int -&gt; Word8</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AdumpBuffer"
+>dumpBuffer</A
+> :: Ptr Word8 -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbufferToCaltime"
+>bufferToCaltime</A
+> :: ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe CalendarTime)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbufferToUTCTime"
+>bufferToUTCTime</A
+> :: ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe UTCTime)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsetBufferByte"
+>setBufferByte</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; Int -&gt; Word8 -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcalTimeToBuffer"
+>calTimeToBuffer</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; CalendarTime -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AutcTimeToBuffer"
+>utcTimeToBuffer</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; UTCTime -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbufferPeekValue"
+>bufferPeekValue</A
+> :: Storable a =&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbufferToA"
+>bufferToA</A
+> :: Storable a =&gt; ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe a)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbufferToCInt"
+>bufferToCInt</A
+> :: ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe CInt)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbufferToInt"
+>bufferToInt</A
+> :: ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe Int)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbufferToCDouble"
+>bufferToCDouble</A
+> :: ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe CDouble)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbufferToDouble"
+>bufferToDouble</A
+> :: ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe Double)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbufferToStmtHandle"
+>bufferToStmtHandle</A
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Documentation</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AOCIStruct"
+></A
+><B
+>OCIStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="ndoc"
+><UL
+><LI
+> Each handle type has its own data type, to prevent stupid errors
+    i.e. using the wrong handle at the wrong time.
+</LI
+><LI
+> In GHC you can simply say <TT
+>data OCIStruct</TT
+> i.e. there's no need for <TT
+>= OCIStruct</TT
+>.
+    I've decided to be more portable, as it doesn't cost much.
+</LI
+><LI
+> Use castPtr if you need to convert handles (say <TT
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+></TT
+> to a more specific type, or vice versa).
+</LI
+></UL
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AOCIStruct"
+></A
+><B
+>OCIStruct</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AOCIHandle"
+></A
+><B
+>OCIHandle</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIStruct"
+>OCIStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AOCIBuffer"
+></A
+><B
+>OCIBuffer</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AOCIBuffer"
+></A
+><B
+>OCIBuffer</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ABufferPtr"
+></A
+><B
+>BufferPtr</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIBuffer"
+>OCIBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ABufferFPtr"
+></A
+><B
+>BufferFPtr</B
+> = ForeignPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIBuffer"
+>OCIBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AColumnResultBuffer"
+></A
+><B
+>ColumnResultBuffer</B
+> = ForeignPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIBuffer"
+>OCIBuffer</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ABindBuffer"
+></A
+><B
+>BindBuffer</B
+> = (ForeignPtr CShort, ForeignPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIBuffer"
+>OCIBuffer</A
+>, ForeignPtr CUShort)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AContext"
+></A
+><B
+>Context</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AContext"
+></A
+><B
+>Context</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AContextPtr"
+></A
+><B
+>ContextPtr</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AContext"
+>Context</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AEnvStruct"
+></A
+><B
+>EnvStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AEnvStruct"
+></A
+><B
+>EnvStruct</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AEnvHandle"
+></A
+><B
+>EnvHandle</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvStruct"
+>EnvStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AErrorStruct"
+></A
+><B
+>ErrorStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AErrorStruct"
+></A
+><B
+>ErrorStruct</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AErrorHandle"
+></A
+><B
+>ErrorHandle</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorStruct"
+>ErrorStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AServerStruct"
+></A
+><B
+>ServerStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AServerStruct"
+></A
+><B
+>ServerStruct</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AServerHandle"
+></A
+><B
+>ServerHandle</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AServerStruct"
+>ServerStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AUserStruct"
+></A
+><B
+>UserStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AUserStruct"
+></A
+><B
+>UserStruct</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AUserHandle"
+></A
+><B
+>UserHandle</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AUserStruct"
+>UserStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AConnStruct"
+></A
+><B
+>ConnStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AConnStruct"
+></A
+><B
+>ConnStruct</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AConnHandle"
+></A
+><B
+>ConnHandle</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnStruct"
+>ConnStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ASessStruct"
+></A
+><B
+>SessStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ASessStruct"
+></A
+><B
+>SessStruct</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASessHandle"
+></A
+><B
+>SessHandle</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ASessStruct"
+>SessStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AStmtStruct"
+></A
+><B
+>StmtStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AStmtStruct"
+></A
+><B
+>StmtStruct</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AStmtHandle"
+></A
+><B
+>StmtHandle</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtStruct"
+>StmtStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ADefnStruct"
+></A
+><B
+>DefnStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ADefnStruct"
+></A
+><B
+>DefnStruct</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ADefnHandle"
+></A
+><B
+>DefnHandle</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ADefnStruct"
+>DefnStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AParamStruct"
+></A
+><B
+>ParamStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AParamStruct"
+></A
+><B
+>ParamStruct</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AParamHandle"
+></A
+><B
+>ParamHandle</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AParamStruct"
+>ParamStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ABindStruct"
+></A
+><B
+>BindStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ABindStruct"
+></A
+><B
+>BindStruct</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ABindHandle"
+></A
+><B
+>BindHandle</B
+> = Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindStruct"
+>BindStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AColumnInfo"
+></A
+><B
+>ColumnInfo</B
+> = (<A HREF="Database-Oracle-OCIFunctions.html#t%3ADefnHandle"
+>DefnHandle</A
+>, <A HREF="Database-Oracle-OCIFunctions.html#t%3AColumnResultBuffer"
+>ColumnResultBuffer</A
+>, ForeignPtr CShort, ForeignPtr CUShort)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AOCIException"
+></A
+><B
+>OCIException</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="ndoc"
+>Low-level, OCI library errors.
+</TD
+></TR
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AOCIException"
+></A
+><B
+>OCIException</B
+> CInt String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:OCIException')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:OCIException" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+>Show <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>Typeable <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+></TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcatchOCI"
+></A
+><B
+>catchOCI</B
+> :: IO a -&gt; (<A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+> -&gt; IO a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AthrowOCI"
+></A
+><B
+>throwOCI</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+> -&gt; a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmkCInt"
+></A
+><B
+>mkCInt</B
+> :: Int -&gt; CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmkCShort"
+></A
+><B
+>mkCShort</B
+> :: CInt -&gt; CShort</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmkCUShort"
+></A
+><B
+>mkCUShort</B
+> :: CInt -&gt; CUShort</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcStrLen"
+></A
+><B
+>cStrLen</B
+> :: CStringLen -&gt; CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcStr"
+></A
+><B
+>cStr</B
+> :: CStringLen -&gt; CString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociEnvCreate"
+></A
+><B
+>ociEnvCreate</B
+> :: Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; CInt -&gt; Ptr a -&gt; FunPtr a -&gt; FunPtr a -&gt; FunPtr a -&gt; CInt -&gt; Ptr (Ptr a) -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociHandleAlloc"
+></A
+><B
+>ociHandleAlloc</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; CInt -&gt; Ptr a -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociHandleFree"
+></A
+><B
+>ociHandleFree</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociErrorGet"
+></A
+><B
+>ociErrorGet</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; CString -&gt; Ptr CInt -&gt; CString -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociParamGet"
+></A
+><B
+>ociParamGet</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociAttrGet"
+></A
+><B
+>ociAttrGet</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; Ptr CInt -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociAttrSet"
+></A
+><B
+>ociAttrSet</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; CInt -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociLogon"
+></A
+><B
+>ociLogon</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; CString -&gt; CInt -&gt; CString -&gt; CInt -&gt; CString -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociLogoff"
+></A
+><B
+>ociLogoff</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociSessionBegin"
+></A
+><B
+>ociSessionBegin</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ASessHandle"
+>SessHandle</A
+> -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociSessionEnd"
+></A
+><B
+>ociSessionEnd</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ASessHandle"
+>SessHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociServerAttach"
+></A
+><B
+>ociServerAttach</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AServerHandle"
+>ServerHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CString -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociServerDetach"
+></A
+><B
+>ociServerDetach</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AServerHandle"
+>ServerHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociTerminate"
+></A
+><B
+>ociTerminate</B
+> :: CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociTransStart"
+></A
+><B
+>ociTransStart</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; Word8 -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociTransCommit"
+></A
+><B
+>ociTransCommit</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociTransRollback"
+></A
+><B
+>ociTransRollback</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociStmtPrepare"
+></A
+><B
+>ociStmtPrepare</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CString -&gt; CInt -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociDefineByPos"
+></A
+><B
+>ociDefineByPos</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ADefnHandle"
+>DefnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; CInt -&gt; CUShort -&gt; Ptr CShort -&gt; Ptr CUShort -&gt; Ptr CUShort -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociStmtExecute"
+></A
+><B
+>ociStmtExecute</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CInt -&gt; CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociStmtFetch"
+></A
+><B
+>ociStmtFetch</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CInt -&gt; CShort -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociBindByPos"
+></A
+><B
+>ociBindByPos</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindHandle"
+>BindHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; CUInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; CInt -&gt; CUShort -&gt; Ptr CShort -&gt; Ptr CUShort -&gt; Ptr CUShort -&gt; CUInt -&gt; Ptr CUInt -&gt; CUInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AociBindDynamic"
+></A
+><B
+>ociBindDynamic</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindHandle"
+>BindHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AContextPtr"
+>ContextPtr</A
+> -&gt; FunPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackInBind"
+>OCICallbackInBind</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AContextPtr"
+>ContextPtr</A
+> -&gt; FunPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackOutBind"
+>OCICallbackOutBind</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AOCICallbackInBind"
+></A
+><B
+>OCICallbackInBind</B
+> = <A HREF="Database-Oracle-OCIFunctions.html#t%3AContextPtr"
+>ContextPtr</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindHandle"
+>BindHandle</A
+> -&gt; CInt -&gt; CInt -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; CInt -&gt; Ptr Word8 -&gt; Ptr CShort -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AOCICallbackOutBind"
+></A
+><B
+>OCICallbackOutBind</B
+> = <A HREF="Database-Oracle-OCIFunctions.html#t%3AContextPtr"
+>ContextPtr</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindHandle"
+>BindHandle</A
+> -&gt; CInt -&gt; CInt -&gt; Ptr <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; Ptr CInt -&gt; Ptr Word8 -&gt; Ptr CShort -&gt; Ptr (Ptr CShort) -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmkOCICallbackInBind"
+></A
+><B
+>mkOCICallbackInBind</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackInBind"
+>OCICallbackInBind</A
+> -&gt; IO (FunPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackInBind"
+>OCICallbackInBind</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmkOCICallbackOutBind"
+></A
+><B
+>mkOCICallbackOutBind</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackOutBind"
+>OCICallbackOutBind</A
+> -&gt; IO (FunPtr <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackOutBind"
+>OCICallbackOutBind</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetOCIErrorMsg2"
+></A
+><B
+>getOCIErrorMsg2</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; Ptr CInt -&gt; CString -&gt; CInt -&gt; IO (CInt, String)</TD
+></TR
+><TR
+><TD CLASS="doc"
+>This is just an auxiliary function for getOCIErrorMsg.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetOCIErrorMsg"
+></A
+><B
+>getOCIErrorMsg</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; IO (CInt, String)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfromEnumOCIErrorCode"
+></A
+><B
+>fromEnumOCIErrorCode</B
+> :: CInt -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AformatErrorCodeDesc"
+></A
+><B
+>formatErrorCodeDesc</B
+> :: CInt -&gt; String -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AformatOCIMsg"
+></A
+><B
+>formatOCIMsg</B
+> :: CInt -&gt; String -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; IO (Int, String)</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Given the two parts of an <TT
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+></TT
+> (the error number and text)
+ get the actual error message from the DBMS and construct an error message
+ from all of these pieces.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AformatMsgCommon"
+></A
+><B
+>formatMsgCommon</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; IO (Int, String)</TD
+></TR
+><TR
+><TD CLASS="doc"
+>We have two format functions: <TT
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AformatEnvMsg"
+>formatEnvMsg</A
+></TT
+> takes the <TT
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+></TT
+>,
+ <TT
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AformatErrorMsg"
+>formatErrorMsg</A
+></TT
+> takes the <TT
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+></TT
+>.
+ They're just type-safe wrappers for <TT
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AformatMsgCommon"
+>formatMsgCommon</A
+></TT
+>.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AformatErrorMsg"
+></A
+><B
+>formatErrorMsg</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; IO (Int, String)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AformatEnvMsg"
+></A
+><B
+>formatEnvMsg</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>OCIException</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; IO (Int, String)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AtestForError"
+></A
+><B
+>testForError</B
+> :: CInt -&gt; String -&gt; a -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>The testForError functions are the only places where OCIException is thrown,
+ so if you want to change or embellish it, your changes will be localised here.
+ These functions factor out common error handling code
+ from the OCI wrapper functions that follow.
+</P
+><P
+>Typically an OCI wrapper function would look like:
+</P
+><PRE
+> handleAlloc handleType env = alloca ptr -&gt; do
+   rc &lt;- ociHandleAlloc env ptr handleType 0 nullPtr
+   if rc &lt; 0
+     then throwOCI (OCIException rc msg)
+     else return ()
+</PRE
+><P
+>where the code from <TT
+>if rc &lt; 0</TT
+> onwards was identical.
+ <TT
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AtestForError"
+>testForError</A
+></TT
+> replaces the code from <TT
+>if rc &lt; 0 ...</TT
+> onwards.
+</P
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AtestForErrorWithPtr"
+></A
+><B
+>testForErrorWithPtr</B
+> :: Storable a =&gt; CInt -&gt; String -&gt; Ptr a -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Like <TT
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AtestForError"
+>testForError</A
+></TT
+> but when the value you want to return
+ is at the end of a pointer.
+ Either there was an error, in which case the pointer probably isn't valid,
+ or there is something at the end of the pointer to return.
+ See <TT
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AdbLogon"
+>dbLogon</A
+></TT
+> and <TT
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AgetHandleAttr"
+>getHandleAttr</A
+></TT
+> for example usage.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AenvCreate"
+></A
+><B
+>envCreate</B
+> :: IO <A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AhandleAlloc"
+></A
+><B
+>handleAlloc</B
+> :: CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AhandleFree"
+></A
+><B
+>handleFree</B
+> :: CInt -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsetHandleAttr"
+></A
+><B
+>setHandleAttr</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; Ptr a -&gt; CInt -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsetHandleAttrString"
+></A
+><B
+>setHandleAttrString</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; String -&gt; CInt -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetHandleAttr"
+></A
+><B
+>getHandleAttr</B
+> :: Storable a =&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>OCIHandle</A
+> -&gt; CInt -&gt; CInt -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetParam"
+></A
+><B
+>getParam</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3AParamHandle"
+>ParamHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AdbLogon"
+></A
+><B
+>dbLogon</B
+> :: String -&gt; String -&gt; String -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvHandle"
+>EnvHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="doc"
+>The OCI Logon function doesn't behave as you'd expect when the password is due to expire.
+ <TT
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociLogon"
+>ociLogon</A
+></TT
+> returns <TT
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SUCCESS_WITH_INFO"
+>oci_SUCCESS_WITH_INFO</A
+></TT
+>,
+ but the <TT
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+></TT
+> returned is not valid.
+ In this case we have to change <TT
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SUCCESS_WITH_INFO"
+>oci_SUCCESS_WITH_INFO</A
+></TT
+>
+ to <TT
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_ERROR"
+>oci_ERROR</A
+></TT
+>,
+ so that the error handling code will catch it and abort. 
+ I don't know why the handle returned isn't valid,
+ as the logon process should be able to complete successfully in this case.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AdbLogoff"
+></A
+><B
+>dbLogoff</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aterminate"
+></A
+><B
+>terminate</B
+> :: IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AserverDetach"
+></A
+><B
+>serverDetach</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AServerHandle"
+>ServerHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AserverAttach"
+></A
+><B
+>serverAttach</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AServerHandle"
+>ServerHandle</A
+> -&gt; String -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetSession"
+></A
+><B
+>getSession</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3ASessHandle"
+>SessHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="doc"
+>Having established a connection (Service Context), now get the Session.
+ You can have more than one session per connection,
+ but I haven't implemented it yet.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsessionBegin"
+></A
+><B
+>sessionBegin</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ASessHandle"
+>SessHandle</A
+> -&gt; CInt -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsessionEnd"
+></A
+><B
+>sessionEnd</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ASessHandle"
+>SessHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbeginTrans"
+></A
+><B
+>beginTrans</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; CInt -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcommitTrans"
+></A
+><B
+>commitTrans</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ArollbackTrans"
+></A
+><B
+>rollbackTrans</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtPrepare"
+></A
+><B
+>stmtPrepare</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; String -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>With the OCI you do queries with these steps:
+</P
+><UL
+><LI
+> prepare your statement (it's just a String) - no communication with DBMS
+</LI
+><LI
+> execute it (this sends it to the DBMS for parsing etc)
+</LI
+><LI
+> allocate result set buffers by calling <TT
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AdefineByPos"
+>defineByPos</A
+></TT
+> for each column
+</LI
+><LI
+> call fetch for each row.
+</LI
+><LI
+> call <TT
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AhandleFree"
+>handleFree</A
+></TT
+> for the <TT
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+></TT
+>
+    (I assume this is the approved way of terminating the query;
+    the OCI docs aren't explicit about this.)
+</LI
+></UL
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtExecute"
+></A
+><B
+>stmtExecute</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>ConnHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AdefineByPos"
+></A
+><B
+>defineByPos</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Int</TD
+><TD CLASS="rdoc"
+>Position
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Int</TD
+><TD CLASS="rdoc"
+>Buffer size in bytes
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; CInt</TD
+><TD CLASS="rdoc"
+>SQL Datatype (from <A HREF="Database-Oracle-OCIConstants.html"
+>Database.Oracle.OCIConstants</A
+>)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3AColumnInfo"
+>ColumnInfo</A
+></TD
+><TD CLASS="rdoc"
+>tuple: (DefnHandle, Ptr to buffer, Ptr to null indicator, Ptr to size of value in buffer)
+</TD
+></TR
+><TR
+><TD CLASS="ndoc" COLSPAN="2"
+><P
+>defineByPos allocates memory for a single column value.
+ The allocated components are:
+</P
+><UL
+><LI
+> the result (i.e. value) - you have to say how big with bufsize.
+</LI
+><LI
+> the null indicator (int16)
+</LI
+><LI
+> the size of the returned data (int16)
+</LI
+></UL
+><P
+>Previously it was the caller's responsibility to free the memory after they're done with it.
+ Now we use <TT
+><A HREF="Foreign-ForeignPtr.html#v%3AmallocForeignPtr"
+>mallocForeignPtr</A
+></TT
+>, so manual memory management is hopefully
+ a thing of the past.
+ The caller will also have to cast the data in bufferptr to the expected type
+ (using <TT
+><A HREF="Foreign-Ptr.html#v%3AcastPtr"
+>castPtr</A
+></TT
+>).
+</P
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Asbph"
+></A
+><B
+>sbph</B
+> :: String -&gt; Int -&gt; Bool -&gt; String -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindByPos"
+></A
+><B
+>bindByPos</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Int</TD
+><TD CLASS="rdoc"
+>Position
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; CShort</TD
+><TD CLASS="rdoc"
+>Null ind: 0 == not null, -1 == null
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+></TD
+><TD CLASS="rdoc"
+>payload
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Int</TD
+><TD CLASS="rdoc"
+>payload size in bytes
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; CInt</TD
+><TD CLASS="rdoc"
+>SQL Datatype (from <A HREF="Database-Oracle-OCIConstants.html"
+>Database.Oracle.OCIConstants</A
+>)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO ()</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindOutputByPos"
+></A
+><B
+>bindOutputByPos</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Int</TD
+><TD CLASS="rdoc"
+>Position
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindBuffer"
+>BindBuffer</A
+></TD
+><TD CLASS="rdoc"
+>triple of (null-ind, payload, output-size)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; Int</TD
+><TD CLASS="rdoc"
+>payload input size in bytes
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; CInt</TD
+><TD CLASS="rdoc"
+>SQL Datatype (from <A HREF="Database-Oracle-OCIConstants.html"
+>Database.Oracle.OCIConstants</A
+>)
+</TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3ABindHandle"
+>BindHandle</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtFetch"
+></A
+><B
+>stmtFetch</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>ErrorHandle</A
+> -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Fetch a single row into the buffers.
+ If you have specified a prefetch count &gt; 1 then the row
+ might already be cached by the OCI library.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmaybeBufferNull"
+></A
+><B
+>maybeBufferNull</B
+> :: ForeignPtr CShort -&gt; Maybe a -&gt; IO a -&gt; IO (Maybe a)</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Short-circuit null test: if the buffer contains a null then return Nothing.
+ Otherwise, run the IO action to extract a value from the buffer and return Just it.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AnullByte"
+></A
+><B
+>nullByte</B
+> :: CChar</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcShort2Int"
+></A
+><B
+>cShort2Int</B
+> :: CShort -&gt; Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcUShort2Int"
+></A
+><B
+>cUShort2Int</B
+> :: CUShort -&gt; Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcuCharToInt"
+></A
+><B
+>cuCharToInt</B
+> :: CUChar -&gt; Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbyteToInt"
+></A
+><B
+>byteToInt</B
+> :: Ptr CUChar -&gt; Int -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbufferToString"
+></A
+><B
+>bufferToString</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3AColumnInfo"
+>ColumnInfo</A
+> -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmakeYear"
+></A
+><B
+>makeYear</B
+> :: Int -&gt; Int -&gt; Int</TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>Oracle's excess-something-or-other encoding for years:
+ year = 100*(c - 100) + (y - 100),
+ c = (year div 100) + 100,
+ y = (year mod 100) + 100.
+</P
+><P
+>+1999 -&gt; 119, 199
+ +0100 -&gt; 101, 100
+ +0001 -&gt; 100, 101
+ -0001 -&gt; 100,  99
+ -0100 -&gt;  99, 100
+ -1999 -&gt;  81,   1
+</P
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmakeYearByte"
+></A
+><B
+>makeYearByte</B
+> :: Int -&gt; Word8</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmakeCentByte"
+></A
+><B
+>makeCentByte</B
+> :: Int -&gt; Word8</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AdumpBuffer"
+></A
+><B
+>dumpBuffer</B
+> :: Ptr Word8 -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbufferToCaltime"
+></A
+><B
+>bufferToCaltime</B
+> :: ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe CalendarTime)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbufferToUTCTime"
+></A
+><B
+>bufferToUTCTime</B
+> :: ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe UTCTime)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsetBufferByte"
+></A
+><B
+>setBufferByte</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; Int -&gt; Word8 -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcalTimeToBuffer"
+></A
+><B
+>calTimeToBuffer</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; CalendarTime -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AutcTimeToBuffer"
+></A
+><B
+>utcTimeToBuffer</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>BufferPtr</A
+> -&gt; UTCTime -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbufferPeekValue"
+></A
+><B
+>bufferPeekValue</B
+> :: Storable a =&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbufferToA"
+></A
+><B
+>bufferToA</B
+> :: Storable a =&gt; ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe a)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbufferToCInt"
+></A
+><B
+>bufferToCInt</B
+> :: ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe CInt)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbufferToInt"
+></A
+><B
+>bufferToInt</B
+> :: ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe Int)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbufferToCDouble"
+></A
+><B
+>bufferToCDouble</B
+> :: ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe CDouble)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbufferToDouble"
+></A
+><B
+>bufferToDouble</B
+> :: ForeignPtr CShort -&gt; <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO (Maybe Double)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbufferToStmtHandle"
+></A
+><B
+>bufferToStmtHandle</B
+> :: <A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>BufferFPtr</A
+> -&gt; IO <A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/Database-PostgreSQL-Enumerator.html view
@@ -0,0 +1,961 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Database.PostgreSQL.Enumerator</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Database.PostgreSQL.Enumerator</FONT
+></TD
+><TD ALIGN="right"
+><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="infohead"
+>Portability</TD
+><TD CLASS="infoval"
+>non-portable</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Stability</TD
+><TD CLASS="infoval"
+>experimental</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Maintainer</TD
+><TD CLASS="infoval"
+>oleg@pobox.com, alistair@abayley.org</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Description</TD
+></TR
+><TR
+><TD CLASS="doc"
+>PostgreSQL implementation of Database.Enumerator.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Synopsis</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ASession"
+>Session</A
+> </TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aconnect"
+>connect</A
+> :: [<A HREF="Database-PostgreSQL-Enumerator.html#t%3AConnectAttr"
+>ConnectAttr</A
+>] -&gt; <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AConnectAttr"
+>ConnectAttr</A
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+>= <A HREF="#v%3ACAhost"
+>CAhost</A
+> String</TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ACAhostaddr"
+>CAhostaddr</A
+> String</TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ACAport"
+>CAport</A
+> String</TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ACAdbname"
+>CAdbname</A
+> String</TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ACAuser"
+>CAuser</A
+> String</TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ACApassword"
+>CApassword</A
+> String</TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ACAconnect_timeout"
+>CAconnect_timeout</A
+> Int</TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ACAoptions"
+>CAoptions</A
+> String</TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ACAsslmode"
+>CAsslmode</A
+> String</TD
+></TR
+><TR
+><TD CLASS="decl"
+>| <A HREF="#v%3ACAservice"
+>CAservice</A
+> String</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AprepareStmt"
+>prepareStmt</A
+> :: String -&gt; QueryString -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>] -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApreparePrefetch"
+>preparePrefetch</A
+> :: Int -&gt; String -&gt; QueryString -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>] -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AprepareQuery"
+>prepareQuery</A
+> :: String -&gt; QueryString -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>] -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AprepareLargeQuery"
+>prepareLargeQuery</A
+> :: Int -&gt; String -&gt; QueryString -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>] -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AprepareCommand"
+>prepareCommand</A
+> :: String -&gt; QueryString -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>] -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Asql"
+>sql</A
+> :: String -&gt; QueryString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Asqlbind"
+>sqlbind</A
+> :: String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; QueryStringTuned</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aprefetch"
+>prefetch</A
+> :: Int -&gt; String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; QueryStringTuned</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Acmdbind"
+>cmdbind</A
+> :: String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; CommandBind</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindType"
+>bindType</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> a =&gt; a -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>module <A HREF="Database-Enumerator.html"
+>Database.Enumerator</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Documentation</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ASession"
+></A
+><B
+>Session</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Session')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:Session" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>Typeable <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> BoundStmt <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> CommandBind <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> QueryString <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> String <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> Query <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> BoundStmt <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryString <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryStringTuned <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> String <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> a <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIPrepared"
+>IPrepared</A
+> PreparedStmtObj <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> BoundStmt BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> (<A HREF="Database-Enumerator.html#t%3ARefCursor"
+>RefCursor</A
+> String) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Double) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Float) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Int) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Int64) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe String) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe UTCTime) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> (<A HREF="Database-Enumerator.html#t%3ANextResultSet"
+>NextResultSet</A
+> mark PreparedStmtObj) <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aconnect"
+></A
+><B
+>connect</B
+> :: [<A HREF="Database-PostgreSQL-Enumerator.html#t%3AConnectAttr"
+>ConnectAttr</A
+>] -&gt; <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AConnectAttr"
+></A
+><B
+>ConnectAttr</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="ndoc"
+>Specify connection options to <TT
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3Aconnect"
+>connect</A
+></TT
+>.
+ You only need to use whatever subset is relevant for your connection.
+</TD
+></TR
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ACAhost"
+></A
+><B
+>CAhost</B
+> String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ACAhostaddr"
+></A
+><B
+>CAhostaddr</B
+> String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ACAport"
+></A
+><B
+>CAport</B
+> String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ACAdbname"
+></A
+><B
+>CAdbname</B
+> String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ACAuser"
+></A
+><B
+>CAuser</B
+> String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ACApassword"
+></A
+><B
+>CApassword</B
+> String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ACAconnect_timeout"
+></A
+><B
+>CAconnect_timeout</B
+> Int</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ACAoptions"
+></A
+><B
+>CAoptions</B
+> String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ACAsslmode"
+></A
+><B
+>CAsslmode</B
+> String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ACAservice"
+></A
+><B
+>CAservice</B
+> String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareStmt"
+></A
+><B
+>prepareStmt</B
+> :: String -&gt; QueryString -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>] -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApreparePrefetch"
+></A
+><B
+>preparePrefetch</B
+> :: Int -&gt; String -&gt; QueryString -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>] -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareQuery"
+></A
+><B
+>prepareQuery</B
+> :: String -&gt; QueryString -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>] -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareLargeQuery"
+></A
+><B
+>prepareLargeQuery</B
+> :: Int -&gt; String -&gt; QueryString -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>] -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareCommand"
+></A
+><B
+>prepareCommand</B
+> :: String -&gt; QueryString -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>] -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Asql"
+></A
+><B
+>sql</B
+> :: String -&gt; QueryString</TD
+></TR
+><TR
+><TD CLASS="doc"
+>The simplest kind of a statement: no tuning parameters,
+ all default, little overhead.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Asqlbind"
+></A
+><B
+>sqlbind</B
+> :: String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; QueryStringTuned</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aprefetch"
+></A
+><B
+>prefetch</B
+> :: Int -&gt; String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; QueryStringTuned</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Acmdbind"
+></A
+><B
+>cmdbind</B
+> :: String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; CommandBind</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindType"
+></A
+><B
+>bindType</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> a =&gt; a -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+></TR
+><TR
+><TD CLASS="doc"
+>bindType is useful when constructing the list of Oids for stmtPrepare.
+ You don't need to pass the actual bind values, just dummy values
+ of the same type (the value isn't used, so <TT
+><A HREF="Prelude.html#v%3Aundefined"
+>undefined</A
+></TT
+> is OK here).
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>module <A HREF="Database-Enumerator.html"
+>Database.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/Database-PostgreSQL-PGFunctions.html view
@@ -0,0 +1,3314 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Database.PostgreSQL.PGFunctions</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Database.PostgreSQL.PGFunctions</FONT
+></TD
+><TD ALIGN="right"
+><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="infohead"
+>Portability</TD
+><TD CLASS="infoval"
+>non-portable</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Stability</TD
+><TD CLASS="infoval"
+>experimental</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Maintainer</TD
+><TD CLASS="infoval"
+>oleg@pobox.com, alistair@abayley.org</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Description</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Simple wrappers for PostgreSQL functions (FFI) plus middle-level
+ wrappers (in the second part of this file)
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Synopsis</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ADBHandleStruct"
+>DBHandleStruct</A
+>  = <A HREF="#v%3APGconn"
+>PGconn</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ADBHandle"
+>DBHandle</A
+> = Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandleStruct"
+>DBHandleStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AStmtStruct"
+>StmtStruct</A
+>  = <A HREF="#v%3APGresult"
+>PGresult</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AResultSetHandle"
+>ResultSetHandle</A
+> = Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AStmtStruct"
+>StmtStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AOid"
+>Oid</A
+> = CUInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AFormat"
+>Format</A
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AVoid"
+>Void</A
+> = ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AParamLen"
+>ParamLen</A
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3APGException"
+>PGException</A
+>  = <A HREF="#v%3APGException"
+>PGException</A
+> Int String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcatchPG"
+>catchPG</A
+> :: IO a -&gt; (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGException"
+>PGException</A
+> -&gt; IO a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AthrowPG"
+>throwPG</A
+> :: Integral a =&gt; a -&gt; String -&gt; any</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ArethrowPG"
+>rethrowPG</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGException"
+>PGException</A
+> -&gt; any</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcStr"
+>cStr</A
+> :: CStringLen -&gt; CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcStrLen"
+>cStrLen</A
+> :: CStringLen -&gt; CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQconnectdb"
+>fPQconnectdb</A
+> :: CString -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQfinish"
+>fPQfinish</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQreset"
+>fPQreset</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQdb"
+>fPQdb</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AConnStatusType"
+>ConnStatusType</A
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQstatus"
+>fPQstatus</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AConnStatusType"
+>ConnStatusType</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQerrorMessage"
+>fPQerrorMessage</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQsetClientEncoding"
+>fPQsetClientEncoding</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ANoticeReceiver"
+>NoticeReceiver</A
+> = Ptr () -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ANoticeProcessor"
+>NoticeProcessor</A
+> = Ptr () -&gt; CString -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmkNoticeReceiver"
+>mkNoticeReceiver</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeReceiver"
+>NoticeReceiver</A
+> -&gt; IO (FunPtr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeReceiver"
+>NoticeReceiver</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmkNoticeProcessor"
+>mkNoticeProcessor</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeProcessor"
+>NoticeProcessor</A
+> -&gt; IO (FunPtr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeProcessor"
+>NoticeProcessor</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQsetNoticeReceiver"
+>fPQsetNoticeReceiver</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; FunPtr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeReceiver"
+>NoticeReceiver</A
+> -&gt; Ptr () -&gt; IO (FunPtr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeReceiver"
+>NoticeReceiver</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQsetNoticeProcessor"
+>fPQsetNoticeProcessor</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; FunPtr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeProcessor"
+>NoticeProcessor</A
+> -&gt; Ptr () -&gt; IO (FunPtr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeProcessor"
+>NoticeProcessor</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQexecParams"
+>fPQexecParams</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString -&gt; CInt -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+> -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AVoid"
+>Void</A
+> -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AParamLen"
+>ParamLen</A
+> -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AFormat"
+>Format</A
+> -&gt; CInt -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQprepare"
+>fPQprepare</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString -&gt; CString -&gt; CInt -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQexecPrepared"
+>fPQexecPrepared</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString -&gt; CInt -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AVoid"
+>Void</A
+> -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AParamLen"
+>ParamLen</A
+> -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AFormat"
+>Format</A
+> -&gt; CInt -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQresultStatus"
+>fPQresultStatus</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AExecStatusType"
+>ExecStatusType</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AExecStatusType"
+>ExecStatusType</A
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQresultErrorMessage"
+>fPQresultErrorMessage</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQclear"
+>fPQclear</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQntuples"
+>fPQntuples</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQnfields"
+>fPQnfields</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQfname"
+>fPQfname</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; CInt -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQfformat"
+>fPQfformat</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQftype"
+>fPQftype</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; CInt -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQgetvalue"
+>fPQgetvalue</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; CInt -&gt; CInt -&gt; IO (Ptr Word8)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQgetisnull"
+>fPQgetisnull</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQgetlength"
+>fPQgetlength</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQcmdStatus"
+>fPQcmdStatus</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQcmdTuples"
+>fPQcmdTuples</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQoidValue"
+>fPQoidValue</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQputCopyData"
+>fPQputCopyData</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; Ptr Word8 -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQputCopyEnd"
+>fPQputCopyEnd</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQgetResult"
+>fPQgetResult</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3APGVerbosity"
+>PGVerbosity</A
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfPQsetErrorVerbosity"
+>fPQsetErrorVerbosity</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGVerbosity"
+>PGVerbosity</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGVerbosity"
+>PGVerbosity</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ALOAccessType"
+>LOAccessType</A
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AWhenceType"
+>WhenceType</A
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aflo_creat"
+>flo_creat</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ALOAccessType"
+>LOAccessType</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aflo_import"
+>flo_import</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aflo_export"
+>flo_export</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+> -&gt; CString -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aflo_open"
+>flo_open</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ALOAccessType"
+>LOAccessType</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aflo_write"
+>flo_write</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; Ptr Word8 -&gt; CUInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aflo_read"
+>flo_read</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; Ptr Word8 -&gt; CUInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aflo_lseek"
+>flo_lseek</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; CInt -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AWhenceType"
+>WhenceType</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aflo_tell"
+>flo_tell</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aflo_close"
+>flo_close</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aflo_unlink"
+>flo_unlink</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetError"
+>getError</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AopenDb"
+>openDb</A
+> :: String -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcloseDb"
+>closeDb</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A HREF="#t%3APGType"
+>PGType</A
+> a  <SPAN CLASS="keyword"
+>where</SPAN
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApgTypeFormat"
+>pgTypeFormat</A
+> :: a -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AFormat"
+>Format</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApgTypeOid"
+>pgTypeOid</A
+> :: a -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApgNewValue"
+>pgNewValue</A
+> :: a -&gt; IO (Ptr Word8)</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApgPeek"
+>pgPeek</A
+> :: Ptr Word8 -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApgSize"
+>pgSize</A
+> :: a -&gt; Int</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3APGBindVal"
+>PGBindVal</A
+>  = <A HREF="#v%3APGBindVal"
+>PGBindVal</A
+> {<TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="recfield"
+><A HREF="#v%3AbindValOid"
+>bindValOid</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+></TR
+><TR
+><TD CLASS="recfield"
+><A HREF="#v%3AbindValFormat"
+>bindValFormat</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AFormat"
+>Format</A
+></TD
+></TR
+><TR
+><TD CLASS="recfield"
+><A HREF="#v%3AbindValSize"
+>bindValSize</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="recfield"
+><A HREF="#v%3AbindValPtr"
+>bindValPtr</A
+> :: (IO (Ptr Word8))</TD
+></TR
+></TABLE
+>}</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AtoCChar"
+>toCChar</A
+> :: Char -&gt; CChar</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfromCChar"
+>fromCChar</A
+> :: CChar -&gt; Char</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AtoCInt"
+>toCInt</A
+> :: Int -&gt; CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Acheck%27stmt"
+>check'stmt</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AExecStatusType"
+>ExecStatusType</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtPrepare"
+>stmtPrepare</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>] -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AnqExec"
+>nqExec</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; IO (String, String, <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AexecCommand"
+>execCommand</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGBindVal"
+>PGBindVal</A
+>] -&gt; IO (String, String, <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AexecPreparedCommand"
+>execPreparedCommand</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGBindVal"
+>PGBindVal</A
+>] -&gt; IO (String, String, <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtExecImm"
+>stmtExecImm</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGBindVal"
+>PGBindVal</A
+>] -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtExecImm0"
+>stmtExecImm0</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtExec0"
+>stmtExec0</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtExec0t"
+>stmtExec0t</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtExec"
+>stmtExec</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGBindVal"
+>PGBindVal</A
+>] -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AexecPrepared"
+>execPrepared</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGBindVal"
+>PGBindVal</A
+>] -&gt; CInt -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aprepare%27n%27exec"
+>prepare'n'exec</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGBindVal"
+>PGBindVal</A
+>] -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtFinalise"
+>stmtFinalise</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValPtr"
+>colValPtr</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO (Ptr Word8)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolVal"
+>colVal</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> a =&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValString"
+>colValString</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValInt"
+>colValInt</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValInt64"
+>colValInt64</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO Int64</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValDouble"
+>colValDouble</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO Double</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValFloat"
+>colValFloat</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO Float</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValUTCTime"
+>colValUTCTime</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO UTCTime</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValCalTime"
+>colValCalTime</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO CalendarTime</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValNull"
+>colValNull</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO Bool</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Asbph"
+>sbph</A
+> :: String -&gt; Int -&gt; Bool -&gt; String -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AnqCopyIn_buflen"
+>nqCopyIn_buflen</A
+> :: Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AnqCopyIn"
+>nqCopyIn</A
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; Handle -&gt; IO ()</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Documentation</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ADBHandleStruct"
+></A
+><B
+>DBHandleStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3APGconn"
+></A
+><B
+>PGconn</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ADBHandle"
+></A
+><B
+>DBHandle</B
+> = Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandleStruct"
+>DBHandleStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AStmtStruct"
+></A
+><B
+>StmtStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3APGresult"
+></A
+><B
+>PGresult</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AResultSetHandle"
+></A
+><B
+>ResultSetHandle</B
+> = Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AStmtStruct"
+>StmtStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AOid"
+></A
+><B
+>Oid</B
+> = CUInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AFormat"
+></A
+><B
+>Format</B
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AVoid"
+></A
+><B
+>Void</B
+> = ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AParamLen"
+></A
+><B
+>ParamLen</B
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3APGException"
+></A
+><B
+>PGException</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3APGException"
+></A
+><B
+>PGException</B
+> Int String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:PGException')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:PGException" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+>Show <A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGException"
+>PGException</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>Typeable <A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGException"
+>PGException</A
+></TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcatchPG"
+></A
+><B
+>catchPG</B
+> :: IO a -&gt; (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGException"
+>PGException</A
+> -&gt; IO a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AthrowPG"
+></A
+><B
+>throwPG</B
+> :: Integral a =&gt; a -&gt; String -&gt; any</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ArethrowPG"
+></A
+><B
+>rethrowPG</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGException"
+>PGException</A
+> -&gt; any</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcStr"
+></A
+><B
+>cStr</B
+> :: CStringLen -&gt; CString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcStrLen"
+></A
+><B
+>cStrLen</B
+> :: CStringLen -&gt; CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQconnectdb"
+></A
+><B
+>fPQconnectdb</B
+> :: CString -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQfinish"
+></A
+><B
+>fPQfinish</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQreset"
+></A
+><B
+>fPQreset</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQdb"
+></A
+><B
+>fPQdb</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AConnStatusType"
+></A
+><B
+>ConnStatusType</B
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQstatus"
+></A
+><B
+>fPQstatus</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AConnStatusType"
+>ConnStatusType</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQerrorMessage"
+></A
+><B
+>fPQerrorMessage</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQsetClientEncoding"
+></A
+><B
+>fPQsetClientEncoding</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ANoticeReceiver"
+></A
+><B
+>NoticeReceiver</B
+> = Ptr () -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ANoticeProcessor"
+></A
+><B
+>NoticeProcessor</B
+> = Ptr () -&gt; CString -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmkNoticeReceiver"
+></A
+><B
+>mkNoticeReceiver</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeReceiver"
+>NoticeReceiver</A
+> -&gt; IO (FunPtr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeReceiver"
+>NoticeReceiver</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmkNoticeProcessor"
+></A
+><B
+>mkNoticeProcessor</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeProcessor"
+>NoticeProcessor</A
+> -&gt; IO (FunPtr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeProcessor"
+>NoticeProcessor</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQsetNoticeReceiver"
+></A
+><B
+>fPQsetNoticeReceiver</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; FunPtr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeReceiver"
+>NoticeReceiver</A
+> -&gt; Ptr () -&gt; IO (FunPtr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeReceiver"
+>NoticeReceiver</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQsetNoticeProcessor"
+></A
+><B
+>fPQsetNoticeProcessor</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; FunPtr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeProcessor"
+>NoticeProcessor</A
+> -&gt; Ptr () -&gt; IO (FunPtr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeProcessor"
+>NoticeProcessor</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQexecParams"
+></A
+><B
+>fPQexecParams</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString -&gt; CInt -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+> -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AVoid"
+>Void</A
+> -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AParamLen"
+>ParamLen</A
+> -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AFormat"
+>Format</A
+> -&gt; CInt -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQprepare"
+></A
+><B
+>fPQprepare</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString -&gt; CString -&gt; CInt -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQexecPrepared"
+></A
+><B
+>fPQexecPrepared</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString -&gt; CInt -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AVoid"
+>Void</A
+> -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AParamLen"
+>ParamLen</A
+> -&gt; Ptr <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AFormat"
+>Format</A
+> -&gt; CInt -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQresultStatus"
+></A
+><B
+>fPQresultStatus</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AExecStatusType"
+>ExecStatusType</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AExecStatusType"
+></A
+><B
+>ExecStatusType</B
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQresultErrorMessage"
+></A
+><B
+>fPQresultErrorMessage</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQclear"
+></A
+><B
+>fPQclear</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQntuples"
+></A
+><B
+>fPQntuples</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQnfields"
+></A
+><B
+>fPQnfields</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQfname"
+></A
+><B
+>fPQfname</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; CInt -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQfformat"
+></A
+><B
+>fPQfformat</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQftype"
+></A
+><B
+>fPQftype</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; CInt -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQgetvalue"
+></A
+><B
+>fPQgetvalue</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; CInt -&gt; CInt -&gt; IO (Ptr Word8)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQgetisnull"
+></A
+><B
+>fPQgetisnull</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQgetlength"
+></A
+><B
+>fPQgetlength</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQcmdStatus"
+></A
+><B
+>fPQcmdStatus</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQcmdTuples"
+></A
+><B
+>fPQcmdTuples</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQoidValue"
+></A
+><B
+>fPQoidValue</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQputCopyData"
+></A
+><B
+>fPQputCopyData</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; Ptr Word8 -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQputCopyEnd"
+></A
+><B
+>fPQputCopyEnd</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQgetResult"
+></A
+><B
+>fPQgetResult</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3APGVerbosity"
+></A
+><B
+>PGVerbosity</B
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfPQsetErrorVerbosity"
+></A
+><B
+>fPQsetErrorVerbosity</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGVerbosity"
+>PGVerbosity</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGVerbosity"
+>PGVerbosity</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ALOAccessType"
+></A
+><B
+>LOAccessType</B
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AWhenceType"
+></A
+><B
+>WhenceType</B
+> = CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aflo_creat"
+></A
+><B
+>flo_creat</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ALOAccessType"
+>LOAccessType</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aflo_import"
+></A
+><B
+>flo_import</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CString -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aflo_export"
+></A
+><B
+>flo_export</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+> -&gt; CString -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aflo_open"
+></A
+><B
+>flo_open</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ALOAccessType"
+>LOAccessType</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aflo_write"
+></A
+><B
+>flo_write</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; Ptr Word8 -&gt; CUInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aflo_read"
+></A
+><B
+>flo_read</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; Ptr Word8 -&gt; CUInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aflo_lseek"
+></A
+><B
+>flo_lseek</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; CInt -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AWhenceType"
+>WhenceType</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aflo_tell"
+></A
+><B
+>flo_tell</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aflo_close"
+></A
+><B
+>flo_close</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aflo_unlink"
+></A
+><B
+>flo_unlink</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetError"
+></A
+><B
+>getError</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AopenDb"
+></A
+><B
+>openDb</B
+> :: String -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcloseDb"
+></A
+><B
+>closeDb</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> <A NAME="t%3APGType"
+></A
+><B
+>PGType</B
+> a  <SPAN CLASS="keyword"
+>where</SPAN
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+>Methods</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApgTypeFormat"
+></A
+><B
+>pgTypeFormat</B
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+>:: a</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+>-&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AFormat"
+>Format</A
+></TD
+><TD CLASS="rdoc"
+>1 == binary (default), 0 == text
+</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApgTypeOid"
+></A
+><B
+>pgTypeOid</B
+> :: a -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApgNewValue"
+></A
+><B
+>pgNewValue</B
+> :: a -&gt; IO (Ptr Word8)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApgPeek"
+></A
+><B
+>pgPeek</B
+> :: Ptr Word8 -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApgSize"
+></A
+><B
+>pgSize</B
+> :: a -&gt; Int</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:PGType')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:PGType" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> CalendarTime</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> Char</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> Double</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> Float</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> Int</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> Int16</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> Int32</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> Int64</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> Integer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> String</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> UTCTime</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> a =&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> (Maybe a)</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3APGBindVal"
+></A
+><B
+>PGBindVal</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="5" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3APGBindVal"
+></A
+><B
+>PGBindVal</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="body" COLSPAN="2"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AbindValOid"
+></A
+><B
+>bindValOid</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AbindValFormat"
+></A
+><B
+>bindValFormat</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AFormat"
+>Format</A
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AbindValSize"
+></A
+><B
+>bindValSize</B
+> :: CInt</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AbindValPtr"
+></A
+><B
+>bindValPtr</B
+> :: (IO (Ptr Word8))</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AtoCChar"
+></A
+><B
+>toCChar</B
+> :: Char -&gt; CChar</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfromCChar"
+></A
+><B
+>fromCChar</B
+> :: CChar -&gt; Char</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AtoCInt"
+></A
+><B
+>toCInt</B
+> :: Int -&gt; CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Acheck%27stmt"
+></A
+><B
+>check'stmt</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AExecStatusType"
+>ExecStatusType</A
+> -&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtPrepare"
+></A
+><B
+>stmtPrepare</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>] -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AnqExec"
+></A
+><B
+>nqExec</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; IO (String, String, <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AexecCommand"
+></A
+><B
+>execCommand</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGBindVal"
+>PGBindVal</A
+>] -&gt; IO (String, String, <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AexecPreparedCommand"
+></A
+><B
+>execPreparedCommand</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGBindVal"
+>PGBindVal</A
+>] -&gt; IO (String, String, <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Oid</A
+>)</TD
+></TR
+><TR
+><TD CLASS="doc"
+>This is for commands, as opposed to queries.
+ The query equivalent of <TT
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AexecPreparedCommand"
+>execPreparedCommand</A
+></TT
+> is <TT
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AstmtExec"
+>stmtExec</A
+></TT
+>.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtExecImm"
+></A
+><B
+>stmtExecImm</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGBindVal"
+>PGBindVal</A
+>] -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtExecImm0"
+></A
+><B
+>stmtExecImm0</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtExec0"
+></A
+><B
+>stmtExec0</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtExec0t"
+></A
+><B
+>stmtExec0t</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtExec"
+></A
+><B
+>stmtExec</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGBindVal"
+>PGBindVal</A
+>] -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AexecPrepared"
+></A
+><B
+>execPrepared</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGBindVal"
+>PGBindVal</A
+>] -&gt; CInt -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aprepare%27n%27exec"
+></A
+><B
+>prepare'n'exec</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; String -&gt; [<A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGBindVal"
+>PGBindVal</A
+>] -&gt; IO (<A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+>, Int)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtFinalise"
+></A
+><B
+>stmtFinalise</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValPtr"
+></A
+><B
+>colValPtr</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO (Ptr Word8)</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Column numbers are zero-indexed, so subtract one
+ from given index (we present a one-indexed interface).
+ So are the row numbers.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolVal"
+></A
+><B
+>colVal</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>PGType</A
+> a =&gt; <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValString"
+></A
+><B
+>colValString</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValInt"
+></A
+><B
+>colValInt</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValInt64"
+></A
+><B
+>colValInt64</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO Int64</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValDouble"
+></A
+><B
+>colValDouble</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO Double</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValFloat"
+></A
+><B
+>colValFloat</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO Float</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValUTCTime"
+></A
+><B
+>colValUTCTime</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO UTCTime</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValCalTime"
+></A
+><B
+>colValCalTime</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO CalendarTime</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValNull"
+></A
+><B
+>colValNull</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>ResultSetHandle</A
+> -&gt; Int -&gt; Int -&gt; IO Bool</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Asbph"
+></A
+><B
+>sbph</B
+> :: String -&gt; Int -&gt; Bool -&gt; String -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AnqCopyIn_buflen"
+></A
+><B
+>nqCopyIn_buflen</B
+> :: Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AnqCopyIn"
+></A
+><B
+>nqCopyIn</B
+> :: <A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; Handle -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/Database-Sqlite-Enumerator.html view
@@ -0,0 +1,559 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Database.Sqlite.Enumerator</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Database.Sqlite.Enumerator</FONT
+></TD
+><TD ALIGN="right"
+><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="infohead"
+>Portability</TD
+><TD CLASS="infoval"
+>non-portable</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Stability</TD
+><TD CLASS="infoval"
+>experimental</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Maintainer</TD
+><TD CLASS="infoval"
+>oleg@pobox.com, alistair@abayley.org</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Description</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Sqlite implementation of Database.Enumerator.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Documentation</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ASession"
+></A
+><B
+>Session</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Session')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:Session" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>Typeable <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> BoundStmt <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> QueryString <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> StmtBind <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> String <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AEnvInquiry"
+>EnvInquiry</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ALastInsertRowid"
+>LastInsertRowid</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> Int64</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> Query <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> BoundStmt <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> PreparedStmtObj <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryString <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> StmtBind <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> String <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> a <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIPrepared"
+>IPrepared</A
+> PreparedStmtObj <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> BoundStmt BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe CalendarTime) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Double) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Int) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe Int64) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe String) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe UTCTime) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Enumerator.html#t%3ADBBind"
+>DBBind</A
+> (Maybe a) <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aconnect"
+></A
+><B
+>connect</B
+> :: String -&gt; <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareStmt"
+></A
+><B
+>prepareStmt</B
+> :: QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApreparePrefetch"
+></A
+><B
+>preparePrefetch</B
+> :: Int -&gt; QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareQuery"
+></A
+><B
+>prepareQuery</B
+> :: QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareLargeQuery"
+></A
+><B
+>prepareLargeQuery</B
+> :: Int -&gt; QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AprepareCommand"
+></A
+><B
+>prepareCommand</B
+> :: QueryString -&gt; <A HREF="Database-Enumerator.html#t%3APreparationA"
+>PreparationA</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Asql"
+></A
+><B
+>sql</B
+> :: String -&gt; QueryString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Asqlbind"
+></A
+><B
+>sqlbind</B
+> :: String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; StmtBind</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aprefetch"
+></A
+><B
+>prefetch</B
+> :: Int -&gt; String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; StmtBind</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Acmdbind"
+></A
+><B
+>cmdbind</B
+> :: String -&gt; [<A HREF="Database-Enumerator.html#t%3ABindA"
+>BindA</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> PreparedStmtObj BindObj] -&gt; StmtBind</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ALastInsertRowid"
+></A
+><B
+>LastInsertRowid</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ALastInsertRowid"
+></A
+><B
+>LastInsertRowid</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:LastInsertRowid')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:LastInsertRowid" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AEnvInquiry"
+>EnvInquiry</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ALastInsertRowid"
+>LastInsertRowid</A
+> <A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Session</A
+> Int64</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>module <A HREF="Database-Enumerator.html"
+>Database.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/Database-Sqlite-SqliteFunctions.html view
@@ -0,0 +1,2160 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Database.Sqlite.SqliteFunctions</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Database.Sqlite.SqliteFunctions</FONT
+></TD
+><TD ALIGN="right"
+><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="infohead"
+>Portability</TD
+><TD CLASS="infoval"
+>non-portable</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Stability</TD
+><TD CLASS="infoval"
+>experimental</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Maintainer</TD
+><TD CLASS="infoval"
+>oleg@pobox.com, alistair@abayley.org</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Description</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Simple wrappers for Sqlite functions (FFI).
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Synopsis</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ADBHandleStruct"
+>DBHandleStruct</A
+>  = <A HREF="#v%3ADBHandleStruct"
+>DBHandleStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ADBHandle"
+>DBHandle</A
+> = Ptr <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandleStruct"
+>DBHandleStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AStmtStruct"
+>StmtStruct</A
+>  = <A HREF="#v%3AStmtStruct"
+>StmtStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AStmtHandle"
+>StmtHandle</A
+> = Ptr <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtStruct"
+>StmtStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ABlob"
+>Blob</A
+> = Ptr Word8</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3ASqliteCallback"
+>SqliteCallback</A
+> a = FunPtr (Ptr a -&gt; CInt -&gt; Ptr CString -&gt; Ptr CString -&gt; IO Int)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AFreeFunPtr"
+>FreeFunPtr</A
+> = FunPtr (Ptr Word8 -&gt; IO ())</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ASqliteException"
+>SqliteException</A
+>  = <A HREF="#v%3ASqliteException"
+>SqliteException</A
+> Int String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcatchSqlite"
+>catchSqlite</A
+> :: IO a -&gt; (<A HREF="Database-Sqlite-SqliteFunctions.html#t%3ASqliteException"
+>SqliteException</A
+> -&gt; IO a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AthrowSqlite"
+>throwSqlite</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ASqliteException"
+>SqliteException</A
+> -&gt; a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteOK"
+>sqliteOK</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteERROR"
+>sqliteERROR</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteROW"
+>sqliteROW</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteDONE"
+>sqliteDONE</A
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcStr"
+>cStr</A
+> :: CStringLen -&gt; CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcStrLen"
+>cStrLen</A
+> :: CStringLen -&gt; CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AUTF16CString"
+>UTF16CString</A
+> = CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A HREF="#t%3AUTF8CString"
+>UTF8CString</A
+> = CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteOpen"
+>sqliteOpen</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF8CString"
+>UTF8CString</A
+> -&gt; Ptr <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteClose"
+>sqliteClose</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqlitePrepare"
+>sqlitePrepare</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF8CString"
+>UTF8CString</A
+> -&gt; CInt -&gt; Ptr <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Ptr CString -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteExec"
+>sqliteExec</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF8CString"
+>UTF8CString</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ASqliteCallback"
+>SqliteCallback</A
+> a -&gt; Ptr a -&gt; Ptr CString -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteColumnCount"
+>sqliteColumnCount</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteStep"
+>sqliteStep</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteFinalise"
+>sqliteFinalise</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteReset"
+>sqliteReset</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteChanges"
+>sqliteChanges</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteLastInsertRowid"
+>sqliteLastInsertRowid</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO CLLong</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteFree"
+>sqliteFree</A
+> :: Ptr a -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteErrcode"
+>sqliteErrcode</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteErrmsg"
+>sqliteErrmsg</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF8CString"
+>UTF8CString</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteColumnBytes"
+>sqliteColumnBytes</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteColumnBlob"
+>sqliteColumnBlob</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ABlob"
+>Blob</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteColumnDouble"
+>sqliteColumnDouble</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO CDouble</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteColumnInt"
+>sqliteColumnInt</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteColumnInt64"
+>sqliteColumnInt64</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO CLLong</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteColumnText"
+>sqliteColumnText</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF8CString"
+>UTF8CString</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteColumnText16"
+>sqliteColumnText16</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF16CString"
+>UTF16CString</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteBindBlob"
+>sqliteBindBlob</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ABlob"
+>Blob</A
+> -&gt; CInt -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AFreeFunPtr"
+>FreeFunPtr</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteBindDouble"
+>sqliteBindDouble</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; CDouble -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteBindInt"
+>sqliteBindInt</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteBindInt64"
+>sqliteBindInt64</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; CLLong -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteBindNull"
+>sqliteBindNull</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteBindText"
+>sqliteBindText</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF8CString"
+>UTF8CString</A
+> -&gt; CInt -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AFreeFunPtr"
+>FreeFunPtr</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AsqliteBindText16"
+>sqliteBindText16</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF16CString"
+>UTF16CString</A
+> -&gt; CInt -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AFreeFunPtr"
+>FreeFunPtr</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetError"
+>getError</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ASqliteException"
+>SqliteException</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AgetAndRaiseError"
+>getAndRaiseError</A
+> :: Int -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AerrorTest"
+>errorTest</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; IO a -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AtestForError"
+>testForError</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; a -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AtestForErrorWithPtr"
+>testForErrorWithPtr</A
+> :: Storable a =&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; Ptr a -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AopenDb"
+>openDb</A
+> :: String -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcloseDb"
+>closeDb</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtExec"
+>stmtExec</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtChanges"
+>stmtChanges</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtPrepare"
+>stmtPrepare</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtFetch"
+>stmtFetch</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtFinalise"
+>stmtFinalise</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AstmtReset"
+>stmtReset</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcheckColumnRange"
+>checkColumnRange</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValInt"
+>colValInt</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValInt64"
+>colValInt64</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO Int64</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValDouble"
+>colValDouble</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO Double</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValString"
+>colValString</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcolValBlob"
+>colValBlob</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO (ForeignPtr <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ABlob"
+>Blob</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindDouble"
+>bindDouble</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; Double -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindInt"
+>bindInt</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; Int -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindInt64"
+>bindInt64</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; Int64 -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindNull"
+>bindNull</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindString"
+>bindString</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; String -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AbindBlob"
+>bindBlob</A
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ABlob"
+>Blob</A
+> -&gt; Int -&gt; IO ()</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Documentation</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ADBHandleStruct"
+></A
+><B
+>DBHandleStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ADBHandleStruct"
+></A
+><B
+>DBHandleStruct</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ADBHandle"
+></A
+><B
+>DBHandle</B
+> = Ptr <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandleStruct"
+>DBHandleStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AStmtStruct"
+></A
+><B
+>StmtStruct</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AStmtStruct"
+></A
+><B
+>StmtStruct</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AStmtHandle"
+></A
+><B
+>StmtHandle</B
+> = Ptr <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtStruct"
+>StmtStruct</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ABlob"
+></A
+><B
+>Blob</B
+> = Ptr Word8</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3ASqliteCallback"
+></A
+><B
+>SqliteCallback</B
+> a = FunPtr (Ptr a -&gt; CInt -&gt; Ptr CString -&gt; Ptr CString -&gt; IO Int)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AFreeFunPtr"
+></A
+><B
+>FreeFunPtr</B
+> = FunPtr (Ptr Word8 -&gt; IO ())</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ASqliteException"
+></A
+><B
+>SqliteException</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3ASqliteException"
+></A
+><B
+>SqliteException</B
+> Int String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:SqliteException')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:SqliteException" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+>Show <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ASqliteException"
+>SqliteException</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+>Typeable <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ASqliteException"
+>SqliteException</A
+></TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcatchSqlite"
+></A
+><B
+>catchSqlite</B
+> :: IO a -&gt; (<A HREF="Database-Sqlite-SqliteFunctions.html#t%3ASqliteException"
+>SqliteException</A
+> -&gt; IO a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AthrowSqlite"
+></A
+><B
+>throwSqlite</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ASqliteException"
+>SqliteException</A
+> -&gt; a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteOK"
+></A
+><B
+>sqliteOK</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteERROR"
+></A
+><B
+>sqliteERROR</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteROW"
+></A
+><B
+>sqliteROW</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteDONE"
+></A
+><B
+>sqliteDONE</B
+> :: CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcStr"
+></A
+><B
+>cStr</B
+> :: CStringLen -&gt; CString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcStrLen"
+></A
+><B
+>cStrLen</B
+> :: CStringLen -&gt; CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AUTF16CString"
+></A
+><B
+>UTF16CString</B
+> = CString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>type</SPAN
+> <A NAME="t%3AUTF8CString"
+></A
+><B
+>UTF8CString</B
+> = CString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteOpen"
+></A
+><B
+>sqliteOpen</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF8CString"
+>UTF8CString</A
+> -&gt; Ptr <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteClose"
+></A
+><B
+>sqliteClose</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqlitePrepare"
+></A
+><B
+>sqlitePrepare</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF8CString"
+>UTF8CString</A
+> -&gt; CInt -&gt; Ptr <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Ptr CString -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteExec"
+></A
+><B
+>sqliteExec</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF8CString"
+>UTF8CString</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ASqliteCallback"
+>SqliteCallback</A
+> a -&gt; Ptr a -&gt; Ptr CString -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteColumnCount"
+></A
+><B
+>sqliteColumnCount</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteStep"
+></A
+><B
+>sqliteStep</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteFinalise"
+></A
+><B
+>sqliteFinalise</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteReset"
+></A
+><B
+>sqliteReset</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteChanges"
+></A
+><B
+>sqliteChanges</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteLastInsertRowid"
+></A
+><B
+>sqliteLastInsertRowid</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO CLLong</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteFree"
+></A
+><B
+>sqliteFree</B
+> :: Ptr a -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteErrcode"
+></A
+><B
+>sqliteErrcode</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteErrmsg"
+></A
+><B
+>sqliteErrmsg</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF8CString"
+>UTF8CString</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteColumnBytes"
+></A
+><B
+>sqliteColumnBytes</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteColumnBlob"
+></A
+><B
+>sqliteColumnBlob</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ABlob"
+>Blob</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteColumnDouble"
+></A
+><B
+>sqliteColumnDouble</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO CDouble</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteColumnInt"
+></A
+><B
+>sqliteColumnInt</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteColumnInt64"
+></A
+><B
+>sqliteColumnInt64</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO CLLong</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteColumnText"
+></A
+><B
+>sqliteColumnText</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF8CString"
+>UTF8CString</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteColumnText16"
+></A
+><B
+>sqliteColumnText16</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF16CString"
+>UTF16CString</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteBindBlob"
+></A
+><B
+>sqliteBindBlob</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ABlob"
+>Blob</A
+> -&gt; CInt -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AFreeFunPtr"
+>FreeFunPtr</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteBindDouble"
+></A
+><B
+>sqliteBindDouble</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; CDouble -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteBindInt"
+></A
+><B
+>sqliteBindInt</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteBindInt64"
+></A
+><B
+>sqliteBindInt64</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; CLLong -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteBindNull"
+></A
+><B
+>sqliteBindNull</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteBindText"
+></A
+><B
+>sqliteBindText</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF8CString"
+>UTF8CString</A
+> -&gt; CInt -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AFreeFunPtr"
+>FreeFunPtr</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AsqliteBindText16"
+></A
+><B
+>sqliteBindText16</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; CInt -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF16CString"
+>UTF16CString</A
+> -&gt; CInt -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AFreeFunPtr"
+>FreeFunPtr</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetError"
+></A
+><B
+>getError</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ASqliteException"
+>SqliteException</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AgetAndRaiseError"
+></A
+><B
+>getAndRaiseError</B
+> :: Int -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AerrorTest"
+></A
+><B
+>errorTest</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; IO a -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AtestForError"
+></A
+><B
+>testForError</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; a -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AtestForErrorWithPtr"
+></A
+><B
+>testForErrorWithPtr</B
+> :: Storable a =&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; CInt -&gt; Ptr a -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AopenDb"
+></A
+><B
+>openDb</B
+> :: String -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcloseDb"
+></A
+><B
+>closeDb</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtExec"
+></A
+><B
+>stmtExec</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="doc"
+>This function is not used internally, so it's only provided
+ as a user convenience.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtChanges"
+></A
+><B
+>stmtChanges</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtPrepare"
+></A
+><B
+>stmtPrepare</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; String -&gt; IO <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtFetch"
+></A
+><B
+>stmtFetch</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO CInt</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtFinalise"
+></A
+><B
+>stmtFinalise</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AstmtReset"
+></A
+><B
+>stmtReset</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcheckColumnRange"
+></A
+><B
+>checkColumnRange</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValInt"
+></A
+><B
+>colValInt</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO Int</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Column numbers are zero-indexed, so subtract one
+ from given index (we present a one-indexed interface).
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValInt64"
+></A
+><B
+>colValInt64</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO Int64</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValDouble"
+></A
+><B
+>colValDouble</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO Double</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValString"
+></A
+><B
+>colValString</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO (Maybe String)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcolValBlob"
+></A
+><B
+>colValBlob</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO (ForeignPtr <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ABlob"
+>Blob</A
+>)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindDouble"
+></A
+><B
+>bindDouble</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; Double -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindInt"
+></A
+><B
+>bindInt</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; Int -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindInt64"
+></A
+><B
+>bindInt64</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; Int64 -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindNull"
+></A
+><B
+>bindNull</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindString"
+></A
+><B
+>bindString</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; String -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AbindBlob"
+></A
+><B
+>bindBlob</B
+> :: <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>DBHandle</A
+> -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>StmtHandle</A
+> -&gt; Int -&gt; <A HREF="Database-Sqlite-SqliteFunctions.html#t%3ABlob"
+>Blob</A
+> -&gt; Int -&gt; IO ()</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/Database-Stub-Enumerator.html view
@@ -0,0 +1,483 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Database.Stub.Enumerator</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Database.Stub.Enumerator</FONT
+></TD
+><TD ALIGN="right"
+><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="infohead"
+>Portability</TD
+><TD CLASS="infoval"
+>non-portable</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Stability</TD
+><TD CLASS="infoval"
+>experimental</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Maintainer</TD
+><TD CLASS="infoval"
+>oleg@pobox.com, alistair@abayley.org</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Description</TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>Stub implementation of Database.Enumerator.
+ Useful for people who can't or won't install a DBMS,
+ so that they can try out the Enumerator interface.
+</P
+><P
+>Currently last last row of any fetch will have a null in its Int columns
+ (this makes it easier to test handling of nulls and DBUnexpectedNull).
+ See fetchIntVal.
+</P
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Synopsis</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3ASession"
+>Session</A
+> </TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AConnParm"
+>ConnParm</A
+>  = <A HREF="#v%3AConnParm"
+>ConnParm</A
+> {<TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="recfield"
+><A HREF="#v%3Auser"
+>user</A
+>, <A HREF="#v%3Apswd"
+>pswd</A
+>, <A HREF="#v%3Adbname"
+>dbname</A
+> :: String</TD
+></TR
+></TABLE
+>}</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aconnect"
+>connect</A
+> :: <A HREF="Database-Stub-Enumerator.html#t%3AConnParm"
+>ConnParm</A
+> -&gt; <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Asql"
+>sql</A
+> :: String -&gt; QueryString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aprefetch"
+>prefetch</A
+> :: Int -&gt; String -&gt; QueryStringTuned</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A HREF="#t%3AQueryResourceUsage"
+>QueryResourceUsage</A
+>  = <A HREF="#v%3AQueryResourceUsage"
+>QueryResourceUsage</A
+> {<TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="recfield"
+><A HREF="#v%3AprefetchRowCount"
+>prefetchRowCount</A
+> :: Int</TD
+></TR
+></TABLE
+>}</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Documentation</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3ASession"
+></A
+><B
+>Session</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Session')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:Session" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AISession"
+>ISession</A
+> <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> QueryString <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Command</A
+> QueryStringTuned <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AIQuery"
+>IQuery</A
+> Query <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+> ColumnBuffer</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryString <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Statement</A
+> QueryStringTuned <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+> Query</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AConnParm"
+></A
+><B
+>ConnParm</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="5" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AConnParm"
+></A
+><B
+>ConnParm</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="body" COLSPAN="2"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3Auser"
+></A
+><B
+>user</B
+>, <A NAME="v%3Apswd"
+></A
+><B
+>pswd</B
+>, <A NAME="v%3Adbname"
+></A
+><B
+>dbname</B
+> :: String</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aconnect"
+></A
+><B
+>connect</B
+> :: <A HREF="Database-Stub-Enumerator.html#t%3AConnParm"
+>ConnParm</A
+> -&gt; <A HREF="Database-Enumerator.html#t%3AConnectA"
+>ConnectA</A
+> <A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Session</A
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Asql"
+></A
+><B
+>sql</B
+> :: String -&gt; QueryString</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aprefetch"
+></A
+><B
+>prefetch</B
+> :: Int -&gt; String -&gt; QueryStringTuned</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>data</SPAN
+> <A NAME="t%3AQueryResourceUsage"
+></A
+><B
+>QueryResourceUsage</B
+> </TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="ndoc"
+>At present the only resource tuning we support is the number of rows
+ prefetched by the FFI library.
+ We use a record to (hopefully) make it easy to add other 
+ tuning parameters later.
+</TD
+></TR
+><TR
+><TD CLASS="section4"
+>Constructors</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="5" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AQueryResourceUsage"
+></A
+><B
+>QueryResourceUsage</B
+></TD
+><TD CLASS="rdoc"
+></TD
+></TR
+><TR
+><TD CLASS="body" COLSPAN="2"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="arg"
+><A NAME="v%3AprefetchRowCount"
+></A
+><B
+>prefetchRowCount</B
+> :: Int</TD
+><TD CLASS="rdoc"
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/Database-Util.html view
@@ -0,0 +1,668 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Database.Util</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Database.Util</FONT
+></TD
+><TD ALIGN="right"
+><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="infohead"
+>Portability</TD
+><TD CLASS="infoval"
+>non-portable</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Stability</TD
+><TD CLASS="infoval"
+>experimental</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Maintainer</TD
+><TD CLASS="infoval"
+>oleg@pobox.com, alistair@abayley.org</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Description</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Utility functions. Mostly used in database back-ends, and tests.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Synopsis</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> Show a =&gt; <A HREF="#t%3AMyShow"
+>MyShow</A
+> a  <SPAN CLASS="keyword"
+>where</SPAN
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Ashow_"
+>show_</A
+> :: a -&gt; String</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aprint_"
+>print_</A
+> :: (MonadIO m, <A HREF="Database-Util.html#t%3AMyShow"
+>MyShow</A
+> a) =&gt; a -&gt; m ()</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmkUTCTime"
+>mkUTCTime</A
+> :: (Integral a, Real b) =&gt; a -&gt; a -&gt; a -&gt; a -&gt; a -&gt; b -&gt; UTCTime</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AmkCalTime"
+>mkCalTime</A
+> :: Integral a =&gt; a -&gt; a -&gt; a -&gt; a -&gt; a -&gt; a -&gt; CalendarTime</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aint64ToDateParts"
+>int64ToDateParts</A
+> :: Int64 -&gt; (Int64, Int64, Int64, Int64, Int64, Int64)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AdatePartsToInt64"
+>datePartsToInt64</A
+> :: (Integral a1, Integral a2, Integral a3, Integral a4, Integral a5, Integral a6) =&gt; (a1, a2, a3, a4, a5, a6) -&gt; Int64</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcalTimeToInt64"
+>calTimeToInt64</A
+> :: CalendarTime -&gt; Int64</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aint64ToCalTime"
+>int64ToCalTime</A
+> :: Int64 -&gt; CalendarTime</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Aint64ToUTCTime"
+>int64ToUTCTime</A
+> :: Int64 -&gt; UTCTime</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AwordsBy"
+>wordsBy</A
+> :: (Char -&gt; Bool) -&gt; String -&gt; [String]</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AskipNonMatch"
+>skipNonMatch</A
+> :: (Char -&gt; Bool) -&gt; String -&gt; [String]</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3Apositions"
+>positions</A
+> :: Eq a =&gt; [a] -&gt; [a] -&gt; [Int]</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApgDatetimetoUTCTime"
+>pgDatetimetoUTCTime</A
+> :: String -&gt; UTCTime</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApgDatetimetoCalTime"
+>pgDatetimetoCalTime</A
+> :: String -&gt; CalendarTime</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApgDatetimeToParts"
+>pgDatetimeToParts</A
+> :: String -&gt; (Int, Int, Int, Int, Int, Double, Int)</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AutcTimeToIsoString"
+>utcTimeToIsoString</A
+> :: (Integral a, Integral b) =&gt; UTCTime -&gt; String -&gt; (a -&gt; a) -&gt; (b -&gt; String) -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AutcTimeToPGDatetime"
+>utcTimeToPGDatetime</A
+> :: UTCTime -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AutcTimeToIsoDatetime"
+>utcTimeToIsoDatetime</A
+> :: UTCTime -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AutcTimeToOdbcDatetime"
+>utcTimeToOdbcDatetime</A
+> :: UTCTime -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AcalTimeToPGDatetime"
+>calTimeToPGDatetime</A
+> :: CalendarTime -&gt; String</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Documentation</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><SPAN CLASS="keyword"
+>class</SPAN
+> Show a =&gt; <A NAME="t%3AMyShow"
+></A
+><B
+>MyShow</B
+> a  <SPAN CLASS="keyword"
+>where</SPAN
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+>Methods</TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Ashow_"
+></A
+><B
+>show_</B
+> :: a -&gt; String</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="section4"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:MyShow')" ALT="show/hide"
+> Instances</TD
+></TR
+><TR
+><TD CLASS="body"
+><DIV ID="i:MyShow" STYLE="display:block;"
+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="Database-Util.html#t%3AMyShow"
+>MyShow</A
+> String</TD
+></TR
+><TR
+><TD CLASS="decl"
+>Show a =&gt; <A HREF="Database-Util.html#t%3AMyShow"
+>MyShow</A
+> a</TD
+></TR
+></TABLE
+></DIV
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aprint_"
+></A
+><B
+>print_</B
+> :: (MonadIO m, <A HREF="Database-Util.html#t%3AMyShow"
+>MyShow</A
+> a) =&gt; a -&gt; m ()</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Like <TT
+><A HREF="System-IO.html#v%3Aprint"
+>print</A
+></TT
+>, except that Strings are not escaped or quoted.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmkUTCTime"
+></A
+><B
+>mkUTCTime</B
+> :: (Integral a, Real b) =&gt; a -&gt; a -&gt; a -&gt; a -&gt; a -&gt; b -&gt; UTCTime</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Convenience for making UTCTimes. Assumes the time given is already UTC time
+ i.e. there's no timezone adjustment.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AmkCalTime"
+></A
+><B
+>mkCalTime</B
+> :: Integral a =&gt; a -&gt; a -&gt; a -&gt; a -&gt; a -&gt; a -&gt; CalendarTime</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aint64ToDateParts"
+></A
+><B
+>int64ToDateParts</B
+> :: Int64 -&gt; (Int64, Int64, Int64, Int64, Int64, Int64)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AdatePartsToInt64"
+></A
+><B
+>datePartsToInt64</B
+> :: (Integral a1, Integral a2, Integral a3, Integral a4, Integral a5, Integral a6) =&gt; (a1, a2, a3, a4, a5, a6) -&gt; Int64</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcalTimeToInt64"
+></A
+><B
+>calTimeToInt64</B
+> :: CalendarTime -&gt; Int64</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aint64ToCalTime"
+></A
+><B
+>int64ToCalTime</B
+> :: Int64 -&gt; CalendarTime</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Aint64ToUTCTime"
+></A
+><B
+>int64ToUTCTime</B
+> :: Int64 -&gt; UTCTime</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AwordsBy"
+></A
+><B
+>wordsBy</B
+> :: (Char -&gt; Bool) -&gt; String -&gt; [String]</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AskipNonMatch"
+></A
+><B
+>skipNonMatch</B
+> :: (Char -&gt; Bool) -&gt; String -&gt; [String]</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3Apositions"
+></A
+><B
+>positions</B
+> :: Eq a =&gt; [a] -&gt; [a] -&gt; [Int]</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApgDatetimetoUTCTime"
+></A
+><B
+>pgDatetimetoUTCTime</B
+> :: String -&gt; UTCTime</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApgDatetimetoCalTime"
+></A
+><B
+>pgDatetimetoCalTime</B
+> :: String -&gt; CalendarTime</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApgDatetimeToParts"
+></A
+><B
+>pgDatetimeToParts</B
+> :: String -&gt; (Int, Int, Int, Int, Int, Double, Int)</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AutcTimeToIsoString"
+></A
+><B
+>utcTimeToIsoString</B
+> :: (Integral a, Integral b) =&gt; UTCTime -&gt; String -&gt; (a -&gt; a) -&gt; (b -&gt; String) -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AutcTimeToPGDatetime"
+></A
+><B
+>utcTimeToPGDatetime</B
+> :: UTCTime -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AutcTimeToIsoDatetime"
+></A
+><B
+>utcTimeToIsoDatetime</B
+> :: UTCTime -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AutcTimeToOdbcDatetime"
+></A
+><B
+>utcTimeToOdbcDatetime</B
+> :: UTCTime -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AcalTimeToPGDatetime"
+></A
+><B
+>calTimeToPGDatetime</B
+> :: CalendarTime -&gt; String</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Assumes CalendarTime is also UTC i.e. ignores ctTZ component.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/Foreign-C-UTF8.html view
@@ -0,0 +1,415 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Foreign.C.UTF8</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="modulebar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><FONT SIZE="6"
+>Foreign.C.UTF8</FONT
+></TD
+><TD ALIGN="right"
+><TABLE CLASS="narrow" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="infohead"
+>Portability</TD
+><TD CLASS="infoval"
+>portable</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Stability</TD
+><TD CLASS="infoval"
+>experimental</TD
+></TR
+><TR
+><TD CLASS="infohead"
+>Maintainer</TD
+><TD CLASS="infoval"
+>alistair@abayley.org</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Description</TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>Marshall Haskell Strings to and from UTF8-encoded CStrings.
+ This module's code is inspired by John Meacham's UTF8 en- &amp; de-coders,
+ and also those found in the HXT library (module Text.XML.HXT.DOM.Unicode).
+</P
+><P
+>Note that the -Len functions all return the length in bytes,
+ not Chars (this is more useful, as you are most likely to want
+ to pass the length to an FFI function, which is most likely
+ expecting the length in bytes). If you want the length in Chars,
+ well, you have the original String, so...
+</P
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Synopsis</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="body"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApeekUTF8String"
+>peekUTF8String</A
+> :: CString -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3ApeekUTF8StringLen"
+>peekUTF8StringLen</A
+> :: CStringLen -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AnewUTF8String"
+>newUTF8String</A
+> :: String -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AwithUTF8String"
+>withUTF8String</A
+> :: String -&gt; (CString -&gt; IO a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AwithUTF8StringLen"
+>withUTF8StringLen</A
+> :: String -&gt; (CStringLen -&gt; IO a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AtoUTF8String"
+>toUTF8String</A
+> :: String -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfromUTF8String"
+>fromUTF8String</A
+> :: String -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AlengthUTF8"
+>lengthUTF8</A
+> :: String -&gt; Int</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AfromUTF8"
+>fromUTF8</A
+> :: [Word8] -&gt; String</TD
+></TR
+><TR
+><TD CLASS="s8"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A HREF="#v%3AtoUTF8"
+>toUTF8</A
+> :: String -&gt; [Word8]</TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Documentation</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApeekUTF8String"
+></A
+><B
+>peekUTF8String</B
+> :: CString -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Analogous to peekCString. Converts UTF8 CString to String.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3ApeekUTF8StringLen"
+></A
+><B
+>peekUTF8StringLen</B
+> :: CStringLen -&gt; IO String</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Analogous to peekCStringLen. Converts UTF8 CString to String.
+ The resulting String will end either when <TT
+>len</TT
+> bytes
+ have been converted, or when a NULL is found.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AnewUTF8String"
+></A
+><B
+>newUTF8String</B
+> :: String -&gt; IO CString</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Analogous to newCString. Creates UTF8 encoded CString.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AwithUTF8String"
+></A
+><B
+>withUTF8String</B
+> :: String -&gt; (CString -&gt; IO a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Analogous to withCString. Creates UTF8 encoded CString.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AwithUTF8StringLen"
+></A
+><B
+>withUTF8StringLen</B
+> :: String -&gt; (CStringLen -&gt; IO a) -&gt; IO a</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Analogous to withCStringLen.
+ The length returned is in bytes (encoding units), not chars.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AtoUTF8String"
+></A
+><B
+>toUTF8String</B
+> :: String -&gt; String</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Convert a Haskell String into a UTF8 String, where each UTF8 byte
+ is represented by its Char equivalent i.e. only chars 0-255 are used.
+ The resulting String can be marshalled to CString directly i.e. with
+ a Latin-1 encoding.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfromUTF8String"
+></A
+><B
+>fromUTF8String</B
+> :: String -&gt; String</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Convert a String that was marshalled from a CString without
+ any decoder applied. This might be useful if the client encoding
+ is unknown, and the user code must convert.
+ We assume that the UTF8 CString was marshalled as if Latin-1
+ i.e. all chars are in the range 0-255.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AlengthUTF8"
+></A
+><B
+>lengthUTF8</B
+> :: String -&gt; Int</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AfromUTF8"
+></A
+><B
+>fromUTF8</B
+> :: [Word8] -&gt; String</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Convert UTF-8 to Unicode.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="decl"
+><A NAME="v%3AtoUTF8"
+></A
+><B
+>toUTF8</B
+> :: String -&gt; [Word8]</TD
+></TR
+><TR
+><TD CLASS="doc"
+>Convert Unicode characters to UTF-8.
+</TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-A.html view
@@ -0,0 +1,170 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (A)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>allocConn</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AallocConn"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>allocEnv</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AallocEnv"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>allocHdl</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AallocHdl"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>allocStmt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AallocStmt"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-B.html view
@@ -0,0 +1,598 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (B)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>BindA</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3ABindA"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>BindBuffer</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ABindBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3ABindBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3ABindBuffer"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>BindHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3ABindHandle"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>BindStruct</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3ABindStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3ABindStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>Blob</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#t%3ABlob"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>Buffer</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ABuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3ABuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>BufferFPtr</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ABufferFPtr"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferFPtr"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>BufferPtr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3ABufferPtr"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>basicDBExceptionReporter</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AbasicDBExceptionReporter"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>beginTrans</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbeginTrans"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>beginTransaction</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AbeginTransaction"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindBlob</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AbindBlob"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindBufPtr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindBufPtr"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindBufSize</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindBufSize"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindBufSzPtr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindBufSzPtr"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindByPos</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbindByPos"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindColBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindColBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindColumnBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindColumnBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindDouble</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AbindDouble"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindEncodedString</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindEncodedString"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AbindInt"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindInt64</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AbindInt64"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>bindNull</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindNull"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AbindNull"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindOutputByPos</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbindOutputByPos"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindP</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AbindP"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindParam</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindParam"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindParamBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindParamBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindParamCAString</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindParamCAString"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindParamCStringLen</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindParamCStringLen"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindParamCWString</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindParamCWString"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindParamUTF8String</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindParamUTF8String"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindParamUtcTime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AbindParamUtcTime"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindString</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AbindString"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindType</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3AbindType"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindValFormat</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AbindValFormat"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindValOid</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AbindValOid"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindValPtr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AbindValPtr"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bindValSize</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AbindValSize"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bufferPeekValue</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbufferPeekValue"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bufferToA</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbufferToA"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bufferToCDouble</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbufferToCDouble"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bufferToCInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbufferToCInt"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bufferToCaltime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbufferToCaltime"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bufferToDouble</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbufferToDouble"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bufferToInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbufferToInt"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bufferToStmtHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbufferToStmtHandle"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bufferToString</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbufferToString"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>bufferToUTCTime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbufferToUTCTime"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>byteToInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AbyteToInt"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-C.html view
@@ -0,0 +1,934 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (C)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>CAconnect_timeout</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3ACAconnect_timeout"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>CAdbname</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3ACAdbname"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>CAhost</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3ACAhost"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>CAhostaddr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3ACAhostaddr"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>CAoptions</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3ACAoptions"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>CApassword</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3ACApassword"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>CAport</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3ACAport"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>CAservice</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3ACAservice"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>CAsslmode</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3ACAsslmode"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>CAuser</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3ACAuser"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>CaughtMonadIO</TD
+><TD CLASS="indexlinks"
+><A HREF="Control-Exception-MonadIO.html#t%3ACaughtMonadIO"
+>Control.Exception.MonadIO</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ColNum</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3AColNum"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ColumnInfo</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AColumnInfo"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ColumnResultBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AColumnResultBuffer"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>Command</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3ACommand"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>ConnHandle</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHandle"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AConnHandle"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AConnHandle"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ConnHdl</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnHdl"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>ConnObj</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AConnObj"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AConnObj"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>ConnParm</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Stub-Enumerator.html#t%3AConnParm"
+>Database.Stub.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Stub-Enumerator.html#v%3AConnParm"
+>Database.Stub.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ConnStatusType</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3AConnStatusType"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>ConnStruct</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AConnStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AConnStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ConnectA</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3AConnectA"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ConnectAttr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#t%3AConnectAttr"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>Context</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AContext"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AContext"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ContextPtr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AContextPtr"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>cShort2Int</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AcShort2Int"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>cStr</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AcStr"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcStr"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AcStr"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>cStrLen</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AcStrLen"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcStrLen"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AcStrLen"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>cUShort2Int</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AcUShort2Int"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>calTimeToBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AcalTimeToBuffer"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>calTimeToInt64</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3AcalTimeToInt64"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>calTimeToPGDatetime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3AcalTimeToPGDatetime"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>catchDB</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AcatchDB"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>catchDBError</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AcatchDBError"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>catchOCI</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AcatchOCI"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>catchOdbc</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AcatchOdbc"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>catchPG</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcatchPG"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>catchSqlite</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AcatchSqlite"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>check'stmt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3Acheck%27stmt"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>checkColumnRange</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AcheckColumnRange"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>checkError</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AcheckError"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>closeCursor</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AcloseCursor"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>closeDb</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcloseDb"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AcloseDb"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>cmdbind</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-Enumerator.html#v%3Acmdbind"
+>Database.ODBC.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#v%3Acmdbind"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3Acmdbind"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-Enumerator.html#v%3Acmdbind"
+>Database.Sqlite.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>colVal</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcolVal"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>colValBlob</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AcolValBlob"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>colValCalTime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcolValCalTime"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>colValDouble</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcolValDouble"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AcolValDouble"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>colValFloat</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcolValFloat"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>colValInt</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcolValInt"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AcolValInt"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>colValInt64</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcolValInt64"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AcolValInt64"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>colValNull</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcolValNull"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>colValPtr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcolValPtr"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>colValString</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcolValString"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AcolValString"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>colValUTCTime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AcolValUTCTime"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>commit</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3Acommit"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3Acommit"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>commitTrans</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AcommitTrans"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>connDbms</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AconnDbms"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>connHdl</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AconnHdl"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>connect</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-Enumerator.html#v%3Aconnect"
+>Database.ODBC.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3Aconnect"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#v%3Aconnect"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3Aconnect"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>5 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-Enumerator.html#v%3Aconnect"
+>Database.Sqlite.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>6 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Stub-Enumerator.html#v%3Aconnect"
+>Database.Stub.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>createBufferForStorable</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AcreateBufferForStorable"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>createBufferHelper</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AcreateBufferHelper"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>createEmptyBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AcreateEmptyBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>cuCharToInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AcuCharToInt"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>currentRowNum</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AcurrentRowNum"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>cursorCurrent</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AcursorCurrent"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>cursorIsEOF</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AcursorIsEOF"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>cursorNext</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AcursorNext"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-D.html view
@@ -0,0 +1,342 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (D)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>DBBind</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3ADBBind"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>DBError</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3ADBError"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>DBException</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3ADBException"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>DBFatal</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3ADBFatal"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>DBHandle</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandle"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandle"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>DBHandleStruct</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3ADBHandleStruct"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#t%3ADBHandleStruct"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3ADBHandleStruct"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>DBM</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3ADBM"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>DBNoData</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3ADBNoData"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>DBType</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3ADBType"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>DBUnexpectedNull</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3ADBUnexpectedNull"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>DefnHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3ADefnHandle"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>DefnStruct</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3ADefnStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3ADefnStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>datePartsToInt64</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3AdatePartsToInt64"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>dbLogoff</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AdbLogoff"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>dbLogon</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AdbLogon"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>dbname</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Stub-Enumerator.html#v%3Adbname"
+>Database.Stub.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>defineByPos</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AdefineByPos"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>disconnect</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3Adisconnect"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>doQuery</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AdoQuery"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>dumpBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AdumpBuffer"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-E.html view
@@ -0,0 +1,306 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (E)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>EnvHandle</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvHandle"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvHandle"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>EnvInquiry</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3AEnvInquiry"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>EnvObj</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AEnvObj"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AEnvObj"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>EnvStruct</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AEnvStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AEnvStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ErrorHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorHandle"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>ErrorStruct</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AErrorStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AErrorStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ExecStatusType</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3AExecStatusType"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>envCreate</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AenvCreate"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>errorTest</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AerrorTest"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>execCommand</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AexecCommand"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>execDDL</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AexecDDL"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>execDML</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AexecDML"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>execPrepared</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AexecPrepared"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>execPreparedCommand</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AexecPreparedCommand"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>executeStmt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AexecuteStmt"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-F.html view
@@ -0,0 +1,594 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (F)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>Format</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3AFormat"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>FreeFunPtr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#t%3AFreeFunPtr"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQclear</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQclear"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQcmdStatus</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQcmdStatus"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQcmdTuples</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQcmdTuples"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQconnectdb</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQconnectdb"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQdb</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQdb"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQerrorMessage</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQerrorMessage"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQexecParams</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQexecParams"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQexecPrepared</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQexecPrepared"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQfformat</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQfformat"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQfinish</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQfinish"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQfname</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQfname"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQftype</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQftype"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQgetResult</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQgetResult"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQgetisnull</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQgetisnull"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQgetlength</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQgetlength"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQgetvalue</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQgetvalue"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQnfields</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQnfields"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQntuples</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQntuples"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQoidValue</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQoidValue"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQprepare</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQprepare"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQputCopyData</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQputCopyData"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQputCopyEnd</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQputCopyEnd"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQreset</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQreset"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQresultErrorMessage</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQresultErrorMessage"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQresultStatus</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQresultStatus"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQsetClientEncoding</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQsetClientEncoding"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQsetErrorVerbosity</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQsetErrorVerbosity"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQsetNoticeProcessor</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQsetNoticeProcessor"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQsetNoticeReceiver</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQsetNoticeReceiver"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fPQstatus</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfPQstatus"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fetch</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3Afetch"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>flo_close</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3Aflo_close"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>flo_creat</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3Aflo_creat"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>flo_export</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3Aflo_export"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>flo_import</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3Aflo_import"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>flo_lseek</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3Aflo_lseek"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>flo_open</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3Aflo_open"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>flo_read</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3Aflo_read"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>flo_tell</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3Aflo_tell"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>flo_unlink</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3Aflo_unlink"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>flo_write</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3Aflo_write"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>formatDBException</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AformatDBException"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>formatEnvMsg</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AformatEnvMsg"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>formatErrorCodeDesc</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AformatErrorCodeDesc"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>formatErrorMsg</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AformatErrorMsg"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>formatMsgCommon</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AformatMsgCommon"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>formatOCIMsg</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AformatOCIMsg"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>freeConn</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AfreeConn"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>freeEnv</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AfreeEnv"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>freeHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AfreeHandle"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>freeStmt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AfreeStmt"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fromCChar</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AfromCChar"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fromEnumOCIErrorCode</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AfromEnumOCIErrorCode"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fromUTF8</TD
+><TD CLASS="indexlinks"
+><A HREF="Foreign-C-UTF8.html#v%3AfromUTF8"
+>Foreign.C.UTF8</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>fromUTF8String</TD
+><TD CLASS="indexlinks"
+><A HREF="Foreign-C-UTF8.html#v%3AfromUTF8String"
+>Foreign.C.UTF8</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-G.html view
@@ -0,0 +1,422 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (G)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>gbracket</TD
+><TD CLASS="indexlinks"
+><A HREF="Control-Exception-MonadIO.html#v%3Agbracket"
+>Control.Exception.MonadIO</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>gcatch</TD
+><TD CLASS="indexlinks"
+><A HREF="Control-Exception-MonadIO.html#v%3Agcatch"
+>Control.Exception.MonadIO</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>gcatchJust</TD
+><TD CLASS="indexlinks"
+><A HREF="Control-Exception-MonadIO.html#v%3AgcatchJust"
+>Control.Exception.MonadIO</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getAndRaiseError</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AgetAndRaiseError"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getCAStringFromBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetCAStringFromBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getCWStringFromBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetCWStringFromBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getData</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetData"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getDataCString</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetDataCString"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getDataCStringLen</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetDataCStringLen"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getDataStorable</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetDataStorable"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getDataUTF8String</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetDataUTF8String"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getDataUtcTime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetDataUtcTime"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getDiagRec</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetDiagRec"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>getError</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AgetError"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AgetError"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getFromBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetFromBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getHandleAttr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AgetHandleAttr"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getInfoDatabaseName</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetInfoDatabaseName"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getInfoDbmsName</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetInfoDbmsName"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getInfoDbmsVer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetInfoDbmsVer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getInfoDriverName</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetInfoDriverName"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getInfoDriverVer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetInfoDriverVer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getInfoString</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetInfoString"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getMaybeFromBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetMaybeFromBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getNativeSql</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetNativeSql"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getOCIErrorMsg</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AgetOCIErrorMsg"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getOCIErrorMsg2</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AgetOCIErrorMsg2"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getParam</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AgetParam"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getSession</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AgetSession"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getStorableFromBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetStorableFromBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getUTF8StringFromBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetUTF8StringFromBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>getUtcTimeFromBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AgetUtcTimeFromBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>gfinally</TD
+><TD CLASS="indexlinks"
+><A HREF="Control-Exception-MonadIO.html#v%3Agfinally"
+>Control.Exception.MonadIO</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>gtry</TD
+><TD CLASS="indexlinks"
+><A HREF="Control-Exception-MonadIO.html#v%3Agtry"
+>Control.Exception.MonadIO</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>gtryJust</TD
+><TD CLASS="indexlinks"
+><A HREF="Control-Exception-MonadIO.html#v%3AgtryJust"
+>Control.Exception.MonadIO</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-H.html view
@@ -0,0 +1,182 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (H)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>Handle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandle"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>HandleObj</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AHandleObj"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AHandleObj"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>handleAlloc</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AhandleAlloc"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>handleFree</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AhandleFree"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-I.html view
@@ -0,0 +1,262 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (I)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>IPrepared</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3AIPrepared"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>IQuery</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3AIQuery"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ISession</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3AISession"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>InOutParam</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AInOutParam"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AInOutParam"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>IsolationLevel</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3AIsolationLevel"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>IterAct</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3AIterAct"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>IterResult</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3AIterResult"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ifNull</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AifNull"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ignoreDBError</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AignoreDBError"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>inquire</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3Ainquire"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>int2Ptr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3Aint2Ptr"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>int64ToCalTime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3Aint64ToCalTime"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>int64ToDateParts</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3Aint64ToDateParts"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>int64ToUTCTime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3Aint64ToUTCTime"
+>Database.Util</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-L.html view
@@ -0,0 +1,174 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (L)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>LOAccessType</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3ALOAccessType"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>LastInsertRowid</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-Enumerator.html#t%3ALastInsertRowid"
+>Database.Sqlite.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-Enumerator.html#v%3ALastInsertRowid"
+>Database.Sqlite.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>lengthUTF8</TD
+><TD CLASS="indexlinks"
+><A HREF="Foreign-C-UTF8.html#v%3AlengthUTF8"
+>Foreign.C.UTF8</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-M.html view
@@ -0,0 +1,290 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (M)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>MyCString</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCString"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>MyCStringLen</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AMyCStringLen"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>MyShow</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#t%3AMyShow"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>makeCentByte</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AmakeCentByte"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>makeUtcTimeBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AmakeUtcTimeBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>makeUtcTimeStringBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AmakeUtcTimeStringBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>makeYear</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AmakeYear"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>makeYearByte</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AmakeYearByte"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>maybeBufferNull</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AmaybeBufferNull"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>mkCInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AmkCInt"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>mkCShort</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AmkCShort"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>mkCUShort</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AmkCUShort"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>mkCalTime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3AmkCalTime"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>mkNoticeProcessor</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AmkNoticeProcessor"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>mkNoticeReceiver</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AmkNoticeReceiver"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>mkOCICallbackInBind</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AmkOCICallbackInBind"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>mkOCICallbackOutBind</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AmkOCICallbackOutBind"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>mkUTCTime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3AmkUTCTime"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>moreResults</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AmoreResults"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-N.html view
@@ -0,0 +1,214 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (N)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>NextResultSet</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3ANextResultSet"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3ANextResultSet"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>NoticeProcessor</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeProcessor"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>NoticeReceiver</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3ANoticeReceiver"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>newUTF8String</TD
+><TD CLASS="indexlinks"
+><A HREF="Foreign-C-UTF8.html#v%3AnewUTF8String"
+>Foreign.C.UTF8</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>nqCopyIn</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AnqCopyIn"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>nqCopyIn_buflen</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AnqCopyIn_buflen"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>nqExec</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AnqExec"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>nullByte</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AnullByte"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-O.html view
@@ -0,0 +1,798 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (O)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>OCIBuffer</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIBuffer"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AOCIBuffer"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>OCICallbackInBind</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackInBind"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>OCICallbackOutBind</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AOCICallbackOutBind"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>OCIException</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIException"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AOCIException"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>OCIHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIHandle"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>OCIStruct</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AOCIStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AOCIStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>OdbcBindBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>OdbcBindParam</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcBindParam"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>OdbcException</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOdbcException"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AOdbcException"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>Oid</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3AOid"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>Out</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-Enumerator.html#t%3AOut"
+>Database.ODBC.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-Enumerator.html#v%3AOut"
+>Database.ODBC.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#t%3AOut"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#v%3AOut"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>OutParam</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AOutParam"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AOutParam"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociAttrGet</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociAttrGet"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociAttrSet</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociAttrSet"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociBindByPos</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociBindByPos"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociBindDynamic</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociBindDynamic"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociDefineByPos</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociDefineByPos"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociEnvCreate</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociEnvCreate"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociErrorGet</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociErrorGet"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociHandleAlloc</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociHandleAlloc"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociHandleFree</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociHandleFree"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociLogoff</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociLogoff"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociLogon</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociLogon"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociParamGet</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociParamGet"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociServerAttach</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociServerAttach"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociServerDetach</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociServerDetach"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociSessionBegin</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociSessionBegin"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociSessionEnd</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociSessionEnd"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociStmtExecute</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociStmtExecute"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociStmtFetch</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociStmtFetch"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociStmtPrepare</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociStmtPrepare"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociTerminate</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociTerminate"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociTransCommit</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociTransCommit"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociTransRollback</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociTransRollback"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ociTransStart</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AociTransStart"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_CRED_EXT</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_CRED_EXT"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_CRED_PROXY</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_CRED_PROXY"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_CRED_RDBMS</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_CRED_RDBMS"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_DEFAULT</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_DEFAULT"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_FETCH_ABSOLUTE</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_FETCH_ABSOLUTE"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_FETCH_FIRST</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_FETCH_FIRST"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_FETCH_LAST</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_FETCH_LAST"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_FETCH_NEXT</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_FETCH_NEXT"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_FETCH_PRIOR</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_FETCH_PRIOR"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_FETCH_RELATIVE</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_FETCH_RELATIVE"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_FETCH_RESERVED</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_FETCH_RESERVED"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_NTV_SYNTAX</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_NTV_SYNTAX"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_AFC</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_AFC"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_AVC</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_AVC"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_BIN</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_BIN"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_CHR</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_CHR"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_DAT</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_DAT"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_FLT</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_FLT"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_INT</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_INT"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_LBI</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_LBI"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_LNG</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_LNG"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_LVB</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_LVB"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_LVC</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_LVC"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_NUM</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_NUM"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_RID</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_RID"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_RSET</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_RSET"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_STR</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_STR"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_UIN</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_UIN"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_VBI</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_VBI"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_VCS</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_VCS"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_SQLT_VNU</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_SQLT_VNU"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_TRANS_READONLY</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_TRANS_READONLY"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_TRANS_READWRITE</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_TRANS_READWRITE"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>oci_TRANS_SERIALIZABLE</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIConstants.html#v%3Aoci_TRANS_SERIALIZABLE"
+>Database.Oracle.OCIConstants</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>openDb</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AopenDb"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AopenDb"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-P.html view
@@ -0,0 +1,678 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (P)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>PGBindVal</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGBindVal"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3APGBindVal"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>PGException</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGException"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3APGException"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>PGType</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGType"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>PGVerbosity</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3APGVerbosity"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>PGconn</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3APGconn"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>PGresult</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3APGresult"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ParamHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AParamHandle"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ParamLen</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3AParamLen"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>ParamStruct</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AParamStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AParamStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>Position</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3APosition"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>PreparationA</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3APreparationA"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>PreparedStmt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3APreparedStmt"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>peekSmallInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3ApeekSmallInt"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>peekUInteger</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3ApeekUInteger"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>peekUSmallInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3ApeekUSmallInt"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>peekUTF8String</TD
+><TD CLASS="indexlinks"
+><A HREF="Foreign-C-UTF8.html#v%3ApeekUTF8String"
+>Foreign.C.UTF8</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>peekUTF8StringLen</TD
+><TD CLASS="indexlinks"
+><A HREF="Foreign-C-UTF8.html#v%3ApeekUTF8StringLen"
+>Foreign.C.UTF8</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>pgDatetimeToParts</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3ApgDatetimeToParts"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>pgDatetimetoCalTime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3ApgDatetimetoCalTime"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>pgDatetimetoUTCTime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3ApgDatetimetoUTCTime"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>pgNewValue</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3ApgNewValue"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>pgPeek</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3ApgPeek"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>pgSize</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3ApgSize"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>pgTypeFormat</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3ApgTypeFormat"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>pgTypeOid</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3ApgTypeOid"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>pokeSmallInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3ApokeSmallInt"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>pokeUInteger</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3ApokeUInteger"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>pokeUSmallInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3ApokeUSmallInt"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>positions</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3Apositions"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>prefetch</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-Enumerator.html#v%3Aprefetch"
+>Database.ODBC.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#v%3Aprefetch"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3Aprefetch"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-Enumerator.html#v%3Aprefetch"
+>Database.Sqlite.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>5 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Stub-Enumerator.html#v%3Aprefetch"
+>Database.Stub.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>prefetchRowCount</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Stub-Enumerator.html#v%3AprefetchRowCount"
+>Database.Stub.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>prepare'n'exec</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3Aprepare%27n%27exec"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>prepareCommand</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-Enumerator.html#v%3AprepareCommand"
+>Database.ODBC.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#v%3AprepareCommand"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3AprepareCommand"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-Enumerator.html#v%3AprepareCommand"
+>Database.Sqlite.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>prepareLargeCommand</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#v%3AprepareLargeCommand"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>prepareLargeQuery</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-Enumerator.html#v%3AprepareLargeQuery"
+>Database.ODBC.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#v%3AprepareLargeQuery"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3AprepareLargeQuery"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-Enumerator.html#v%3AprepareLargeQuery"
+>Database.Sqlite.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>preparePrefetch</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-Enumerator.html#v%3ApreparePrefetch"
+>Database.ODBC.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#v%3ApreparePrefetch"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3ApreparePrefetch"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-Enumerator.html#v%3ApreparePrefetch"
+>Database.Sqlite.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>prepareQuery</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-Enumerator.html#v%3AprepareQuery"
+>Database.ODBC.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#v%3AprepareQuery"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3AprepareQuery"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-Enumerator.html#v%3AprepareQuery"
+>Database.Sqlite.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>prepareStmt</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-Enumerator.html#v%3AprepareStmt"
+>Database.ODBC.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AprepareStmt"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#v%3AprepareStmt"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3AprepareStmt"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>5 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-Enumerator.html#v%3AprepareStmt"
+>Database.Sqlite.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>print_</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3Aprint_"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>pswd</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Stub-Enumerator.html#v%3Apswd"
+>Database.Stub.Enumerator</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-Q.html view
@@ -0,0 +1,158 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (Q)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>QueryResourceUsage</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Stub-Enumerator.html#t%3AQueryResourceUsage"
+>Database.Stub.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Stub-Enumerator.html#v%3AQueryResourceUsage"
+>Database.Stub.Enumerator</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-R.html view
@@ -0,0 +1,282 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (R)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>ReadCommitted</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AReadCommitted"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ReadUncommitted</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AReadUncommitted"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>RefCursor</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3ARefCursor"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3ARefCursor"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>RepeatableRead</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3ARepeatableRead"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ResultSetHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3AResultSetHandle"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>RowNum</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3ARowNum"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>readUtcTimeFromMemory</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AreadUtcTimeFromMemory"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>reportRethrow</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AreportRethrow"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>reportRethrowMsg</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AreportRethrowMsg"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>result</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3Aresult"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>result'</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3Aresult%27"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>rethrowPG</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3ArethrowPG"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>rollback</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3Arollback"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3Arollback"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>rollbackTrans</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3ArollbackTrans"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>rowCount</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3ArowCount"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-S.html view
@@ -0,0 +1,1372 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (S)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>Serialisable</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3ASerialisable"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>Serializable</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3ASerializable"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>ServerHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AServerHandle"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>ServerStruct</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AServerStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AServerStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SessHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3ASessHandle"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>SessStruct</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3ASessStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3ASessStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>Session</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-Enumerator.html#t%3ASession"
+>Database.ODBC.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#t%3ASession"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#t%3ASession"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-Enumerator.html#t%3ASession"
+>Database.Sqlite.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>5 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Stub-Enumerator.html#t%3ASession"
+>Database.Stub.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SizeFPtr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ASizeFPtr"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlCDataType</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlCDataType"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlDataType</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlDataType"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlHandleType</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlHandleType"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlInfoType</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInfoType"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlInteger</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlInteger"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlLen</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlLen"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlParamDirection</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlParamDirection"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlReturn</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlReturn"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlSmallInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlSmallInt"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlState</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3ASqlState"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlStateClass</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3ASqlStateClass"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlStateSubClass</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3ASqlStateSubClass"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlUInteger</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUInteger"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlULen</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlULen"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqlUSmallInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3ASqlUSmallInt"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>SqliteCallback</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#t%3ASqliteCallback"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>SqliteException</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#t%3ASqliteException"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3ASqliteException"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>Statement</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#t%3AStatement"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>StmtHandle</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHandle"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AStmtHandle"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtHandle"
+>Database.Oracle.OCIFunctions</A
+>, <A HREF="Database-Oracle-Enumerator.html#t%3AStmtHandle"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtHandle"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>StmtHdl</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtHdl"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>StmtObj</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AStmtObj"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AStmtObj"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>StmtStruct</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AStmtStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AStmtStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3AStmtStruct"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#t%3AStmtStruct"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>5 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AStmtStruct"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>sbph</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3Asbph"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3Asbph"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>serverAttach</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AserverAttach"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>serverDetach</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AserverDetach"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sessionBegin</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AsessionBegin"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sessionEnd</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AsessionEnd"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>setAutoCommitOff</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsetAutoCommitOff"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>setAutoCommitOn</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsetAutoCommitOn"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>setBufferByte</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AsetBufferByte"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>setHandleAttr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AsetHandleAttr"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>setHandleAttrString</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AsetHandleAttrString"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>setOdbcVer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsetOdbcVer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>setTxnIsolation</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsetTxnIsolation"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>show_</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3Ashow_"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sizeOfMaybe</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsizeOfMaybe"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>skipNonMatch</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3AskipNonMatch"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>sql</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-Enumerator.html#v%3Asql"
+>Database.ODBC.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#v%3Asql"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3Asql"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-Enumerator.html#v%3Asql"
+>Database.Sqlite.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>5 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Stub-Enumerator.html#v%3Asql"
+>Database.Stub.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlAllocHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlAllocHandle"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlAutoCommitOff</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlAutoCommitOff"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlAutoCommitOn</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlAutoCommitOn"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlBindCol</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlBindCol"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlBindParameter</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlBindParameter"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlCloseCursor</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlCloseCursor"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlDescribeCol</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlDescribeCol"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlDisconnect</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlDisconnect"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlDriverConnect</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlDriverConnect"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlDriverNoPrompt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlDriverNoPrompt"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlEndTran</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlEndTran"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlExecute</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlExecute"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlFetch</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlFetch"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlFreeHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlFreeHandle"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlGetData</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlGetData"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlGetDiagRec</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlGetDiagRec"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlGetInfo</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlGetInfo"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlMoreResults</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlMoreResults"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlNativeSql</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlNativeSql"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlNullData</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlNullData"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlNullTermedString</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlNullTermedString"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlNumResultCols</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlNumResultCols"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlPrepare</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlPrepare"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlRowCount</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlRowCount"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlSetConnectAttr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlSetConnectAttr"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlSetEnvAttr</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlSetEnvAttr"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlTransCommit</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlTransCommit"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlTransRollback</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AsqlTransRollback"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>sqlbind</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-Enumerator.html#v%3Asqlbind"
+>Database.ODBC.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-Enumerator.html#v%3Asqlbind"
+>Database.Oracle.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-Enumerator.html#v%3Asqlbind"
+>Database.PostgreSQL.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>4 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-Enumerator.html#v%3Asqlbind"
+>Database.Sqlite.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteBindBlob</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteBindBlob"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteBindDouble</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteBindDouble"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteBindInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteBindInt"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteBindInt64</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteBindInt64"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteBindNull</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteBindNull"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteBindText</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteBindText"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteBindText16</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteBindText16"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteChanges</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteChanges"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteClose</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteClose"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteColumnBlob</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteColumnBlob"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteColumnBytes</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteColumnBytes"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteColumnCount</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteColumnCount"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteColumnDouble</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteColumnDouble"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteColumnInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteColumnInt"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteColumnInt64</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteColumnInt64"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteColumnText</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteColumnText"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteColumnText16</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteColumnText16"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteDONE</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteDONE"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteERROR</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteERROR"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteErrcode</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteErrcode"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteErrmsg</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteErrmsg"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteExec</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteExec"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteFinalise</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteFinalise"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteFree</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteFree"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteLastInsertRowid</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteLastInsertRowid"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteOK</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteOK"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteOpen</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteOpen"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqlitePrepare</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqlitePrepare"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteROW</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteROW"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteReset</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteReset"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>sqliteStep</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AsqliteStep"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>stmtChanges</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AstmtChanges"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>stmtDbms</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AstmtDbms"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>stmtExec</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AstmtExec"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AstmtExec"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>stmtExec0</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AstmtExec0"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>stmtExec0t</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AstmtExec0t"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>stmtExecImm</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AstmtExecImm"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>stmtExecImm0</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AstmtExecImm0"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>stmtExecute</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AstmtExecute"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>stmtFetch</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AstmtFetch"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AstmtFetch"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>stmtFinalise</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AstmtFinalise"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AstmtFinalise"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>stmtHdl</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AstmtHdl"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>stmtPrepare</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AstmtPrepare"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AstmtPrepare"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>3 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AstmtPrepare"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>stmtReset</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AstmtReset"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-T.html view
@@ -0,0 +1,266 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (T)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>terminate</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3Aterminate"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>testForError</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AtestForError"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AtestForError"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>testForErrorWithPtr</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AtestForErrorWithPtr"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Function)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AtestForErrorWithPtr"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>testForNull</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AtestForNull"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>throwDB</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AthrowDB"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>throwOCI</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AthrowOCI"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>throwOdbc</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AthrowOdbc"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>throwPG</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AthrowPG"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>throwSqlite</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#v%3AthrowSqlite"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>toCChar</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AtoCChar"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>toCInt</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#v%3AtoCInt"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>toUTF8</TD
+><TD CLASS="indexlinks"
+><A HREF="Foreign-C-UTF8.html#v%3AtoUTF8"
+>Foreign.C.UTF8</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>toUTF8String</TD
+><TD CLASS="indexlinks"
+><A HREF="Foreign-C-UTF8.html#v%3AtoUTF8String"
+>Foreign.C.UTF8</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-U.html view
@@ -0,0 +1,230 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (U)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>UTF16CString</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF16CString"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>UTF8CString</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Sqlite-SqliteFunctions.html#t%3AUTF8CString"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>UserHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AUserHandle"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry" COLSPAN="2"
+>UserStruct</TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>1 (Type/Class)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#t%3AUserStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexannot"
+>2 (Data Constructor)</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AUserStruct"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>user</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Stub-Enumerator.html#v%3Auser"
+>Database.Stub.Enumerator</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>utcTimeToBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Oracle-OCIFunctions.html#v%3AutcTimeToBuffer"
+>Database.Oracle.OCIFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>utcTimeToIsoDatetime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3AutcTimeToIsoDatetime"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>utcTimeToIsoString</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3AutcTimeToIsoString"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>utcTimeToOdbcDatetime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3AutcTimeToOdbcDatetime"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>utcTimeToPGDatetime</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3AutcTimeToPGDatetime"
+>Database.Util</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-V.html view
@@ -0,0 +1,146 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (V)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>Void</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3AVoid"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index-W.html view
@@ -0,0 +1,242 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index (W)</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD CLASS="indexentry"
+>WhenceType</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-PostgreSQL-PGFunctions.html#t%3AWhenceType"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>WindowHandle</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#t%3AWindowHandle"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>withBoundStatement</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AwithBoundStatement"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>withContinuedSession</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AwithContinuedSession"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>withCursor</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AwithCursor"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>withPreparedStatement</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AwithPreparedStatement"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>withSession</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AwithSession"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>withTransaction</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Enumerator.html#v%3AwithTransaction"
+>Database.Enumerator</A
+>, Database.ODBC.Enumerator, Database.Oracle.Enumerator, Database.PostgreSQL.Enumerator, Database.Sqlite.Enumerator</TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>withUTF8String</TD
+><TD CLASS="indexlinks"
+><A HREF="Foreign-C-UTF8.html#v%3AwithUTF8String"
+>Foreign.C.UTF8</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>withUTF8StringLen</TD
+><TD CLASS="indexlinks"
+><A HREF="Foreign-C-UTF8.html#v%3AwithUTF8StringLen"
+>Foreign.C.UTF8</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>wordsBy</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-Util.html#v%3AwordsBy"
+>Database.Util</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>wrapSizedBuffer</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AwrapSizedBuffer"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+><TR
+><TD CLASS="indexentry"
+>writeUTCTimeToMemory</TD
+><TD CLASS="indexlinks"
+><A HREF="Database-ODBC-OdbcFunctions.html#v%3AwriteUTCTimeToMemory"
+>Database.ODBC.OdbcFunctions</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/doc-index.html view
@@ -0,0 +1,132 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC. (Index)</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Index</TD
+></TR
+><TR
+><TD
+><TABLE CELLPADDING="0" CELLSPACING="5"
+><TR
+><TD
+><A HREF="doc-index-A.html"
+>A</A
+></TD
+><TD
+><A HREF="doc-index-B.html"
+>B</A
+></TD
+><TD
+><A HREF="doc-index-C.html"
+>C</A
+></TD
+><TD
+><A HREF="doc-index-D.html"
+>D</A
+></TD
+><TD
+><A HREF="doc-index-E.html"
+>E</A
+></TD
+><TD
+><A HREF="doc-index-F.html"
+>F</A
+></TD
+><TD
+><A HREF="doc-index-G.html"
+>G</A
+></TD
+><TD
+><A HREF="doc-index-H.html"
+>H</A
+></TD
+><TD
+><A HREF="doc-index-I.html"
+>I</A
+></TD
+><TD
+><A HREF="doc-index-L.html"
+>L</A
+></TD
+><TD
+><A HREF="doc-index-M.html"
+>M</A
+></TD
+><TD
+><A HREF="doc-index-N.html"
+>N</A
+></TD
+><TD
+><A HREF="doc-index-O.html"
+>O</A
+></TD
+><TD
+><A HREF="doc-index-P.html"
+>P</A
+></TD
+><TD
+><A HREF="doc-index-Q.html"
+>Q</A
+></TD
+><TD
+><A HREF="doc-index-R.html"
+>R</A
+></TD
+><TD
+><A HREF="doc-index-S.html"
+>S</A
+></TD
+><TD
+><A HREF="doc-index-T.html"
+>T</A
+></TD
+><TD
+><A HREF="doc-index-U.html"
+>U</A
+></TD
+><TD
+><A HREF="doc-index-V.html"
+>V</A
+></TD
+><TD
+><A HREF="doc-index-W.html"
+>W</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/haddock.css view
@@ -0,0 +1,235 @@+/* -------- Global things --------- */++BODY { +  background-color: #ffffff;+  color: #000000;+  font-family: sans-serif;+  } ++A:link    { color: #0000e0; text-decoration: none }+A:visited { color: #0000a0; text-decoration: none }+A:hover   { background-color: #e0e0ff; text-decoration: none }++TABLE.vanilla {+  width: 100%;+  border-width: 0px;+  /* I can't seem to specify cellspacing or cellpadding properly using CSS... */+}++TABLE.vanilla2 {+  border-width: 0px;+}++/* <TT> font is a little too small in MSIE */+TT  { font-size: 100%; }+PRE { font-size: 100%; }++LI P { margin: 0pt } ++TD {+  border-width: 0px;+}++TABLE.narrow {+  border-width: 0px;+}++TD.s8  {  height: 8px;  }+TD.s15 {  height: 15px; }++SPAN.keyword { text-decoration: underline; }++/* Resize the buttom image to match the text size */+IMG.coll { width : 0.75em; height: 0.75em; margin-bottom: 0; margin-right: 0.5em }++/* --------- Contents page ---------- */++DIV.node {+  padding-left: 3em;+}++DIV.cnode {+  padding-left: 1.75em;+}++SPAN.pkg {+  position: absolute;+  left: 50em;+}++/* --------- Documentation elements ---------- */++TD.children {+  padding-left: 25px;+  }++TD.synopsis {+  padding: 2px;+  background-color: #f0f0f0;+  font-family: monospace+ }++TD.decl { +  padding: 2px;+  background-color: #f0f0f0; +  font-family: monospace;+  vertical-align: top;+  }++/* +  arg is just like decl, except that wrapping is not allowed.  It is+  used for function and constructor arguments which have a text box+  to the right, where if wrapping is allowed the text box squashes up+  the declaration by wrapping it.+*/+TD.arg { +  padding: 2px;+  background-color: #f0f0f0; +  font-family: monospace;+  vertical-align: top;+  white-space: nowrap;+  }++TD.recfield { padding-left: 20px }++TD.doc  { +  padding-top: 2px;+  padding-left: 10px;+  }++TD.ndoc  { +  padding: 2px;+  }++TD.rdoc  { +  padding: 2px;+  padding-left: 10px;+  width: 100%;+  }++TD.body  { +  padding-left: 10px+  }++TD.pkg {+  width: 100%;+  padding-left: 10px+}++TD.indexentry {+  vertical-align: top;+  padding-right: 10px+  }++TD.indexannot {+  vertical-align: top;+  padding-left: 20px;+  white-space: nowrap+  }++TD.indexlinks {+  width: 100%+  }++/* ------- Section Headings ------- */++TD.section1 {+  padding-top: 15px;+  font-weight: bold;+  font-size: 150%+  }++TD.section2 {+  padding-top: 10px;+  font-weight: bold;+  font-size: 130%+  }++TD.section3 {+  padding-top: 5px;+  font-weight: bold;+  font-size: 110%+  }++TD.section4 {+  font-weight: bold;+  font-size: 100%+  }++/* -------------- The title bar at the top of the page */++TD.infohead {+  color: #ffffff;+  font-weight: bold;+  padding-right: 10px;+  text-align: left;+}++TD.infoval {+  color: #ffffff;+  padding-right: 10px;+  text-align: left;+}++TD.topbar {+  background-color: #000099;+  padding: 5px;+}++TD.title {+  color: #ffffff;+  padding-left: 10px;+  width: 100%+  }++TD.topbut {+  padding-left: 5px;+  padding-right: 5px;+  border-left-width: 1px;+  border-left-color: #ffffff;+  border-left-style: solid;+  white-space: nowrap;+  }++TD.topbut A:link {+  color: #ffffff+  }++TD.topbut A:visited {+  color: #ffff00+  }++TD.topbut A:hover {+  background-color: #6060ff;+  }++TD.topbut:hover {+  background-color: #6060ff+  }++TD.modulebar { +  background-color: #0077dd;+  padding: 5px;+  border-top-width: 1px;+  border-top-color: #ffffff;+  border-top-style: solid;+  }++/* --------- The page footer --------- */++TD.botbar {+  background-color: #000099;+  color: #ffffff;+  padding: 5px+  }+TD.botbar A:link {+  color: #ffffff;+  text-decoration: underline+  }+TD.botbar A:visited {+  color: #ffff00+  }+TD.botbar A:hover {+  background-color: #6060ff+  }+
+ doc/html/haddock.js view
@@ -0,0 +1,15 @@+// Haddock JavaScript utilities+function toggle(button,id)+{+   var n = document.getElementById(id).style;+   if (n.display == "none")+   {+	button.src = "minus.gif";+	n.display = "block";+   }+   else+   {+	button.src = "plus.gif";+	n.display = "none";+   }+}
+ doc/html/haskell_icon.gif view

binary file changed (absent → 911 bytes)

+ doc/html/index.html view
@@ -0,0 +1,375 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"
+><TITLE
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TITLE
+><LINK HREF="haddock.css" REL="stylesheet" TYPE="text/css"
+><SCRIPT SRC="haddock.js" TYPE="text/javascript"
+></SCRIPT
+></HEAD
+><BODY
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD CLASS="topbar"
+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD
+><IMG SRC="haskell_icon.gif" WIDTH="16" HEIGHT="16" ALT=" "
+></TD
+><TD CLASS="title"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+><TD CLASS="topbut"
+><A HREF="index.html"
+>Contents</A
+></TD
+><TD CLASS="topbut"
+><A HREF="doc-index.html"
+>Index</A
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Takusen-0.8.2: Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC.</TD
+></TR
+><TR
+><TD CLASS="doc"
+><P
+>Takusen is a DBMS access library. Like HSQL and HDBC, we support
+arbitrary SQL statements (currently strings, extensible to anything
+that can be converted to a string).
+</P
+><P
+>Takusen's unique selling point is safety and efficiency.
+We statically ensure all acquired database resources - such
+as cursors, connections, and statement handles - are released, exactly
+once, at predictable times. Takusen can avoid loading the whole result
+set in memory, and so can handle queries returning millions of rows in
+constant space. Takusen also supports automatic marshalling and
+unmarshalling of results and query parameters. These benefits come
+from the design of query result processing around a left-fold
+enumerator.
+</P
+><P
+>Currently we fully support ODBC, Oracle, Sqlite, and PostgreSQL.
+</P
+></TD
+></TR
+><TR
+><TD CLASS="section1"
+>Modules</TD
+></TR
+><TR
+><TD
+><TABLE CLASS="vanilla2" CELLSPACING="0" CELLPADDING="0"
+><TR
+><TD STYLE="width: 50em"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'n:0')" ALT="show/hide"
+>Control</TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding: 0; padding-left: 2em" COLSPAN="3"
+><TABLE CLASS="vanilla2" CELLSPACING="0" CELLPADDING="0" ID="n:0" STYLE="display:block;"
+><TR
+><TD STYLE="width: 48em"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'n:1')" ALT="show/hide"
+>Exception</TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding: 0; padding-left: 2em" COLSPAN="3"
+><TABLE CLASS="vanilla2" CELLSPACING="0" CELLPADDING="0" ID="n:1" STYLE="display:block;"
+><TR
+><TD STYLE="padding-left: 1.25em;width: 46em"
+><A HREF="Control-Exception-MonadIO.html"
+>Control.Exception.MonadIO</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD STYLE="width: 50em"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'n:2')" ALT="show/hide"
+>Database</TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding: 0; padding-left: 2em" COLSPAN="3"
+><TABLE CLASS="vanilla2" CELLSPACING="0" CELLPADDING="0" ID="n:2" STYLE="display:block;"
+><TR
+><TD STYLE="padding-left: 1.25em;width: 48em"
+><A HREF="Database-Enumerator.html"
+>Database.Enumerator</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="width: 48em"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'n:3')" ALT="show/hide"
+>ODBC</TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding: 0; padding-left: 2em" COLSPAN="3"
+><TABLE CLASS="vanilla2" CELLSPACING="0" CELLPADDING="0" ID="n:3" STYLE="display:block;"
+><TR
+><TD STYLE="padding-left: 1.25em;width: 46em"
+><A HREF="Database-ODBC-Enumerator.html"
+>Database.ODBC.Enumerator</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding-left: 1.25em;width: 46em"
+><A HREF="Database-ODBC-OdbcFunctions.html"
+>Database.ODBC.OdbcFunctions</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD STYLE="width: 48em"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'n:4')" ALT="show/hide"
+>Oracle</TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding: 0; padding-left: 2em" COLSPAN="3"
+><TABLE CLASS="vanilla2" CELLSPACING="0" CELLPADDING="0" ID="n:4" STYLE="display:block;"
+><TR
+><TD STYLE="padding-left: 1.25em;width: 46em"
+><A HREF="Database-Oracle-Enumerator.html"
+>Database.Oracle.Enumerator</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding-left: 1.25em;width: 46em"
+><A HREF="Database-Oracle-OCIConstants.html"
+>Database.Oracle.OCIConstants</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding-left: 1.25em;width: 46em"
+><A HREF="Database-Oracle-OCIFunctions.html"
+>Database.Oracle.OCIFunctions</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD STYLE="width: 48em"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'n:5')" ALT="show/hide"
+>PostgreSQL</TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding: 0; padding-left: 2em" COLSPAN="3"
+><TABLE CLASS="vanilla2" CELLSPACING="0" CELLPADDING="0" ID="n:5" STYLE="display:block;"
+><TR
+><TD STYLE="padding-left: 1.25em;width: 46em"
+><A HREF="Database-PostgreSQL-Enumerator.html"
+>Database.PostgreSQL.Enumerator</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding-left: 1.25em;width: 46em"
+><A HREF="Database-PostgreSQL-PGFunctions.html"
+>Database.PostgreSQL.PGFunctions</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD STYLE="width: 48em"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'n:6')" ALT="show/hide"
+>Sqlite</TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding: 0; padding-left: 2em" COLSPAN="3"
+><TABLE CLASS="vanilla2" CELLSPACING="0" CELLPADDING="0" ID="n:6" STYLE="display:block;"
+><TR
+><TD STYLE="padding-left: 1.25em;width: 46em"
+><A HREF="Database-Sqlite-Enumerator.html"
+>Database.Sqlite.Enumerator</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding-left: 1.25em;width: 46em"
+><A HREF="Database-Sqlite-SqliteFunctions.html"
+>Database.Sqlite.SqliteFunctions</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD STYLE="width: 48em"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'n:7')" ALT="show/hide"
+>Stub</TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding: 0; padding-left: 2em" COLSPAN="3"
+><TABLE CLASS="vanilla2" CELLSPACING="0" CELLPADDING="0" ID="n:7" STYLE="display:block;"
+><TR
+><TD STYLE="padding-left: 1.25em;width: 46em"
+><A HREF="Database-Stub-Enumerator.html"
+>Database.Stub.Enumerator</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD STYLE="padding-left: 1.25em;width: 48em"
+><A HREF="Database-Util.html"
+>Database.Util</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD STYLE="width: 50em"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'n:8')" ALT="show/hide"
+>Foreign</TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding: 0; padding-left: 2em" COLSPAN="3"
+><TABLE CLASS="vanilla2" CELLSPACING="0" CELLPADDING="0" ID="n:8" STYLE="display:block;"
+><TR
+><TD STYLE="width: 48em"
+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'n:9')" ALT="show/hide"
+>C</TD
+><TD
+></TD
+><TD
+></TD
+></TR
+><TR
+><TD STYLE="padding: 0; padding-left: 2em" COLSPAN="3"
+><TABLE CLASS="vanilla2" CELLSPACING="0" CELLPADDING="0" ID="n:9" STYLE="display:block;"
+><TR
+><TD STYLE="padding-left: 1.25em;width: 46em"
+><A HREF="Foreign-C-UTF8.html"
+>Foreign.C.UTF8</A
+></TD
+><TD
+></TD
+><TD
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+></TABLE
+></TD
+></TR
+><TR
+><TD CLASS="s15"
+></TD
+></TR
+><TR
+><TD CLASS="botbar"
+>Produced by <A HREF="http://www.haskell.org/haddock/"
+>Haddock</A
+> version 0.7</TD
+></TR
+></TABLE
+></BODY
+></HTML
+>
+ doc/html/minus.gif view

binary file changed (absent → 56 bytes)

+ doc/html/plus.gif view

binary file changed (absent → 59 bytes)