dummy persistent connection

Dummy.hs

{-# LANGUAGE OverloadedStrings #-}

import qualified Data.Text.IO as T
import Database.Persist.Sql
import Data.Monoid
import Data.Conduit
import Data.Acquire
import Data.IORef
import qualified Data.Map as Map
import qualified Data.Conduit.List as CL
import Control.Monad.Reader

mkDummyConn = do
  stmtmap  <- newIORef (Map.empty)
  return $
    SqlBackend
    { connPrepare     = prepare
    , connInsertSql   = insert
    , connInsertManySql = Nothing
    , connStmtMap     = stmtmap
    , connClose       = putStrLn "(closing connection)"
    , connMigrateSql  = undefined
    , connBegin       = const (putStrLn "BEGIN")
    , connCommit      = const (putStrLn "COMMIT")
    , connRollback    = const (putStrLn "ROLLBACK")
    , connEscapeName  = escapeName
    , connNoLimit     = "MyNoLimit"
    , connRDBMS       = "MyRDBMS"
    , connLimitOffset = limitoffset
    , connLogFunc     = logfunc
    }
  where
    escapeName txt = "ESCAPE(" <> unDBName txt <> ")"
    prepare txt = do T.putStrLn $ "PREPARE: " <> txt
                     return dummyStmt
    insert entitydef pvalues = ISRSingle ""
    limitoffset (i,j) b t = t  -- XXX
    logfunc loc src level str = return ()

dummyStmt = 
  Statement
  { stmtFinalize = putStrLn "(finalizing stmt)"
  , stmtReset    = putStrLn "(resetting stmt)"
  , stmtExecute  = execute   
  , stmtQuery    = query
  }
  where
    execute params = do putStrLn $ "(executing stmt with: " ++ show params ++ ")"; return 0
    query params = mkAcquire (return emptySource) (const (return ()))

emptySource ::  Monad m => Source m o
emptySource = return ()

test1 = do
  dummyBackend <- mkDummyConn
  let sql = "SELECT name FROM Person WHERE name LIKE '%Snoyman'"
  runReaderT (rawExecute sql []) dummyBackend