Haskell: Persist.sqlite - only select

Question

I'm trying to use Persist.sqlite to query my DB,..but in all the tutorials I have found so far is that first I have to migrate and insert data. Only after that came the select.

But what if I want to do only select over existing data? No migration and inserts before?

For example in the code below. What if I want to skip buildDb (currently that will not work)?

{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE QuasiQuotes, TemplateHaskell, TypeFamilies #-}
{-# LANGUAGE OverloadedStrings, GADTs, FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}

module DBio where

import Data.Text (Text)
import Database.Persist
import Database.Persist.Sqlite (runSqlite, runMigrationSilent)
import Database.Persist.TH (mkPersist, mkMigrate, persistLowerCase,
       share, sqlSettings)
import Database.Persist.Sql (insert)
import Data.Conduit (($$))
import Data.Conduit.List as CL
import Control.Monad.IO.Class (liftIO)


share [mkPersist sqlSettings, mkMigrate "migrateTables"] [persistLowerCase|
Tutorial
   value    Double
   url      Text
   school   Bool
   deriving Show
|]


run :: IO ()
run = runSqlite "../DB/mind.sqlite" $ do
   buildDb
   basic <- selectList [TutorialValue >. 0.0] []
   liftIO $ print basic

buildDb = do
   --runMigrationSilent migrateTables
   insert $ Tutorial 2.22 "https://fpcomplete.com/school/basic-haskell-1" True

for example if I comment buildDb, after the table was once created i get following error:

No instance for (Control.Monad.IO.Class.MonadIO m0)
  arising from a use of ‘insert’
The type variable ‘m0’ is ambiguous
Relevant bindings include
  buildDb :: Control.Monad.Trans.Reader.ReaderT
               persistent-2.2:Database.Persist.Sql.Types.SqlBackend
               m0
               (Key Tutorial)
    (bound at DBio.hs:35:1)
Note: there are several potential instances:
  instance Control.Monad.IO.Class.MonadIO m =>
           Control.Monad.IO.Class.MonadIO
             (conduit-1.2.5:Data.Conduit.Internal.Conduit.ConduitM i o m)
    -- Defined in ‘conduit-1.2.5:Data.Conduit.Internal.Conduit’
  instance Control.Monad.IO.Class.MonadIO m =>
           Control.Monad.IO.Class.MonadIO
             (conduit-1.2.5:Data.Conduit.Internal.Pipe.Pipe l i o u m)
    -- Defined in ‘conduit-1.2.5:Data.Conduit.Internal.Pipe’
  instance Control.Monad.IO.Class.MonadIO IO
    -- Defined in ‘Control.Monad.IO.Class’
  ...plus 16 others
In the expression: insert
In a stmt of a 'do' block:
  insert
  $ Tutorial
      2.22 "https://fpcomplete.com/school/basic-haskell-1" True
In the expression:
  do { insert
       $ Tutorial
           2.22 "https://fpcomplete.com/school/basic-haskell-1" True }

Answer 1

I managed to get a working example. I guess that the problem above is with import modules.

{-# LANGUAGE OverloadedStrings, GADTs, TypeFamilies #-}
{-# LANGUAGE QuasiQuotes, TemplateHaskell #-}
{-# LANGUAGE MultiParamTypeClasses, GeneralizedNewtypeDeriving #-}

import Database.Persist ((>.), insertMany, Entity(..))
import Database.Persist.Sqlite (runSqlite,runMigration)
import qualified Database.Persist.TH as TH (share, mkPersist, sqlSettings, 
   mkMigrate, persistLowerCase)
import Control.Monad (mapM_)
import Database.Persist (selectList, entityVal)
import Database.Persist.Sqlite (runSqlite)
import Control.Monad.IO.Class  (liftIO)


TH.share [TH.mkPersist TH.sqlSettings, TH.mkMigrate "migrateAll"] [TH.persistLowerCase|
MyRecord
  value Int
  deriving Show
|]

create :: IO ()
create = runSqlite "test.sqlite" $ do
  let n = 10
  runMigration migrateAll
  insertMany $ map MyRecord [1..n]
  return ()

get :: IO ()
get = runSqlite "test.sqlite" $ do
   records <- selectList [MyRecordValue >. 9] []
   liftIO $ print records