da528b7 · project-m36 · git.iko.soy

git.iko.soy/project-m36

on master help sign in

refactor Tutorial D interpreter to make use of client library

da528b7AgentM11 years ago

ProjectM36/Base.hs+2−1

compare with master

unifiedsplit

@@ -265,4 +265,5 @@ instance Binary AttributeNames

265data PersistenceStrategy = NoPersistence | --no filesystem persistence/memory-only database

266 MinimalPersistence FilePath --fsync off

267 --CrashSafePersistence FilePath --full fsync- not yet implemented

268− deriving (Show, Read)

268+ deriving (Show, Read)

269+

ProjectM36/RelationalExpression.hs+2−1

@@ -521,4 +521,5 @@ intAtomFuncLessThan _ _= BoolAtom False

521

522boolAtomNot :: [Atom] -> Atom

523boolAtomNot (BoolAtom bool:_) = BoolAtom $ not bool

524−boolAtomNot _ = BoolAtom False

524+boolAtomNot _ = BoolAtom False

525+

TutorialD/Interpreter.hs+49−47

@@ -7,16 +7,13 @@ import TutorialD.Interpreter.TransactionGraphOperator

7import ProjectM36.Base

8import ProjectM36.Relation.Show.Term

9import ProjectM36.TransactionGraph

10+import ProjectM36.Client

10import Text.Parsec

11import Text.Parsec

11import Text.Parsec.String

12import Text.Parsec.String

12import Control.Monad.State

13import Control.Monad.State

13import System.Console.Haskeline

14import System.Console.Haskeline

14−import System.IO

15import System.Directory (getHomeDirectory)

16−import qualified Data.UUID as U

17−import Data.UUID.V4 (nextRandom)

18import qualified Data.Text as T

16import qualified Data.Text as T

19−import qualified Data.Text.IO as TIO

20import Control.Applicative ((<*))

17import Control.Applicative ((<*))

22{-

19{-

@@ -43,56 +40,61 @@ promptText (DisconnectedTransaction parentUUID _) graph = "TutorialD (" `T.appen

43 Right parentTrans -> case headNameForTransaction parentTrans graph of

40 Right parentTrans -> case headNameForTransaction parentTrans graph of

44 Nothing -> T.pack (show $ transactionUUID parentTrans)

41 Nothing -> T.pack (show $ transactionUUID parentTrans)

45 Just headName -> headName

42 Just headName -> headName

43+

44+parseTutorialD :: Connection -> String -> Either ParseError ParsedOperation

45+parseTutorialD (InProcessConnection _ _) inputString = parse interpreterParserP "" inputString

47−interpret :: U.UUID -> DisconnectedTransaction -> TransactionGraph -> String -> (TutorialDOperatorResult, DisconnectedTransaction, TransactionGraph, TransactionGraphWasUpdated)

47+--execute the operation and display result

48−interpret freshUUID discon@(DisconnectedTransaction parentUUID context) graph inputString = case parse interpreterParserP "" inputString of

48+evalTutorialD :: Connection -> ParsedOperation -> IO (TutorialDOperatorResult)

49− Left err -> (DisplayErrorResult (T.pack $ show err), discon, graph, False)

49+evalTutorialD conn expr = case expr of

50+

51+ --this does not pass through the ProjectM36.Client library because the operations

52+ --are specific to the interpreter, though some operations may be of general use in the future

53+ (RODatabaseContextOp execOp) -> do

54+ (DisconnectedTransaction _ context) <- disconnectedTransaction conn

50− Right (RODatabaseContextOp execOp) -> (evalRODatabaseContextOp context execOp, discon, graph, False)

55+ return $ evalRODatabaseContextOp context execOp

56+

51− Right (DatabaseExprOp execOp) -> case evalDatabaseExpr True context execOp of

57+ (DatabaseExprOp execOp) -> do

52− Left err -> (DisplayErrorResult $ T.pack (show err), discon, graph, False)

58+ maybeErr <- executeDatabaseContextExpr conn execOp

53− Right context' -> (QuietSuccessResult, DisconnectedTransaction parentUUID context', graph, False)

59+ case maybeErr of

54− Right (GraphOp execOp) -> case evalGraphOp freshUUID discon graph execOp of

60+ Just err -> barf err

55− Left err -> (DisplayErrorResult $ T.pack (show err), discon, graph, False)

61+ Nothing -> return $ QuietSuccessResult

62+

63+ (GraphOp execOp) -> do

64+ maybeErr <- executeGraphExpr conn execOp

65+ case maybeErr of

66+ Just err -> barf err

56− Right (discon', graph') -> (QuietSuccessResult, discon', graph', True)

67+ Nothing -> return $ QuietSuccessResult

68+

69+ (ROGraphOp execOp) -> do

70+ discon <- disconnectedTransaction conn

71+ graph <- transactionGraph conn

57− Right (ROGraphOp execOp) -> case evalROGraphOp discon graph execOp of

72+ case evalROGraphOp discon graph execOp of

58− Left err -> (DisplayErrorResult $ T.pack (show err), discon, graph, False)

73+ Left err -> barf err

59− Right rel -> (DisplayResult $ showRelation rel, discon, graph, False)

74+ Right rel -> return $ DisplayResult $ showRelation rel

60−

75+

76+ where

77+ barf err = return $ DisplayErrorResult (T.pack (show err))

78+

61data InterpreterConfig = InterpreterConfig {

79data InterpreterConfig = InterpreterConfig {

62 persistenceStrategy :: PersistenceStrategy

80 persistenceStrategy :: PersistenceStrategy

63 }

81 }

65−reprLoop :: InterpreterConfig -> DisconnectedTransaction -> TransactionGraph -> IO ()

83+reprLoop :: InterpreterConfig -> Connection -> IO ()

66−reprLoop config currentTransaction graph = do

84+reprLoop config conn = do

67 homeDirectory <- getHomeDirectory

85 homeDirectory <- getHomeDirectory

68 let settings = defaultSettings {historyFile = Just (homeDirectory ++ "/.tutd_history")}

86 let settings = defaultSettings {historyFile = Just (homeDirectory ++ "/.tutd_history")}

69−

87+ discon <- disconnectedTransaction conn

88+ graph <- transactionGraph conn

70− maybeLine <- runInputT settings $ getInputLine (T.unpack (promptText currentTransaction graph))

89+ maybeLine <- runInputT settings $ getInputLine (T.unpack (promptText discon graph))

71−

72− let roloop = reprLoop config currentTransaction graph

90+ let roloop = reprLoop config conn

73 case maybeLine of

91 case maybeLine of

74 Nothing -> return ()

92 Nothing -> return ()

75 Just line -> do

93 Just line -> do

76− newUUID <- nextRandom

94+ case parseTutorialD conn line of

77− let (opResult, disconTrans, updatedGraph, graphWasUpdated) = interpret newUUID currentTransaction graph line

95+ Left err -> do

78− when graphWasUpdated $ processPersistence (persistenceStrategy config) updatedGraph

79− case (opResult, disconTrans, updatedGraph) of

80− (QuitResult, _, _) -> return ()

81− (DisplayErrorResult err, _, _) -> TIO.hPutStrLn stderr ("ERROR: " `T.append` err) >> roloop

96+ displayOpResult $ DisplayErrorResult (T.pack (show err))

82− (DisplayIOResult outio, updatedTrans', updatedGraph') -> do

97+ roloop

83− outio

98+ Right parsed -> do

84− reprLoop config updatedTrans' updatedGraph'

99+ evald <- evalTutorialD conn parsed

85− (DisplayResult out, updatedTrans', updatedGraph') -> do

100+ displayOpResult evald

86− TIO.putStrLn out

87− --assume that the DisplayResult type implies that the transaction graph was not updated

88− reprLoop config updatedTrans' updatedGraph'

89− (QuietSuccessResult, updatedTrans', updatedGraph') -> do

90− --save the current transaction graph

91− TIO.putStrLn "Done."

92− reprLoop config updatedTrans' updatedGraph'

93−

94−--used by :dumpGraph

95−{-

96−displayTransactionGraph :: TransactionGraph -> String

97−displayTransactionGraph (TransactionGraph _ transSet) = L.intercalate "\n" $ S.foldr (\(Transaction tUUID pUUID _ ) acc -> acc ++ [show tUUID ++ " " ++ show pUUID]) [] transSet

98−-}

TutorialD/Interpreter/Base.hs−4

@@ -10,7 +10,6 @@ import qualified Data.List as L

10import qualified Data.Vector as V

11import qualified Data.Text.IO as TIO

12import System.IO

13−import ProjectM36.TransactionGraph.Persist

15lexer :: Token.TokenParser ()

14lexer :: Token.TokenParser ()

16lexer = Token.makeTokenParser tutD

15lexer = Token.makeTokenParser tutD

@@ -78,6 +77,3 @@ displayOpResult (DisplayIOResult ioout) = ioout

78displayOpResult (DisplayErrorResult err) = TIO.hPutStrLn stderr ("ERR: " `T.append` err)

77displayOpResult (DisplayErrorResult err) = TIO.hPutStrLn stderr ("ERR: " `T.append` err)

79displayOpResult QuietSuccessResult = return ()

78displayOpResult QuietSuccessResult = return ()

81−processPersistence :: PersistenceStrategy -> TransactionGraph -> IO ()

82−processPersistence NoPersistence _ = return ()

83−processPersistence (MinimalPersistence dbdir) graph = transactionGraphPersist dbdir graph

TutorialD/Interpreter/TransactionGraphOperator.hs−1

@@ -6,7 +6,6 @@ import Text.Parsec.String

6import qualified Data.UUID as U

7import qualified Data.Text as T

8import ProjectM36.TransactionGraph

9−import ProjectM36.Relation.Show.Term

11jumpToHeadP :: Parser TransactionGraphOperator

10jumpToHeadP :: Parser TransactionGraphOperator

12jumpToHeadP = do

11jumpToHeadP = do

TutorialD/tutd.hs+9−33

@@ -1,14 +1,9 @@

1{-# LANGUAGE OverloadedStrings #-}

2import TutorialD.Interpreter

3−import ProjectM36.RelationalExpression

4−import ProjectM36.TransactionGraph

5−import ProjectM36.TransactionGraph.Persist

6−import ProjectM36.Transaction

7import ProjectM36.Base

3import ProjectM36.Base

4+import ProjectM36.Client

8import System.IO

5import System.IO

9import Options.Applicative

6import Options.Applicative

10−import Data.UUID.V4 (nextRandom)

11−import qualified Data.Text as T

12import System.Exit

7import System.Exit

14{-

9{-

@@ -33,37 +28,18 @@ parsePersistenceStrategy = do

36−configSetup :: InterpreterConfig -> IO (TransactionGraph)

37−configSetup config = do

38− let failHard msg = do

39− hPutStrLn stderr msg

40− exitFailure

41− firstGraphUUID <- nextRandom

42− let bootstrapGraph = bootstrapTransactionGraph firstGraphUUID dateExamples

43− case persistenceStrategy config of

44− --create date examples graph for now- probably should be empty context in the future

45− NoPersistence -> do { putStrLn "Running without filesystem persistence."; return bootstrapGraph}

46− MinimalPersistence dbdir -> do

47− err <- setupDatabaseDir dbdir bootstrapGraph

48− case err of

49− Just err' -> failHard ("Failed to configure database: " ++ show err')

50− Nothing -> do

51− graph <- transactionGraphLoad dbdir emptyTransactionGraph

52− case graph of

53− Left err' -> failHard ("Failed to load graph: " ++ show err')

54− Right graph' -> return graph'

55−

56opts :: ParserInfo InterpreterConfig

31opts :: ParserInfo InterpreterConfig

57opts = info parseArgs idm

32opts = info parseArgs idm

59main :: IO ()

34main :: IO ()

60main = do

35main = do

61 interpreterConfig <- execParser opts

36 interpreterConfig <- execParser opts

62− let currentHeadName = "master"

37+ dbconn <- connectProjectM36 (InProcessConnectionInfo (persistenceStrategy interpreterConfig))

63− freshGraph <- configSetup interpreterConfig

38+ case dbconn of

64− case transactionForHead currentHeadName freshGraph of

39+ Left err -> do

65− Nothing -> hPutStrLn stderr $ "Failed to find head transaction for " ++ T.unpack currentHeadName ++ "."

40+ hPutStrLn stderr ("Failed to create database connection: " ++ show err)

66− Just headTransaction -> do

41+ exitFailure

67− let currentTransaction = newDisconnectedTransaction (transactionUUID headTransaction) (transactionContext headTransaction)

42+ Right conn -> do

68− reprLoop interpreterConfig currentTransaction freshGraph

43+ _ <- reprLoop interpreterConfig conn

44+ return ()

project-m36.cabal+3−2

@@ -7,7 +7,7 @@ Category: Relational Algebra

7Cabal-Version: >= 1.2

9Library

10− Build-Depends: base,mtl,containers,unordered-containers,parsec,hashable,haskeline,directory,uuid,cassava,text,bytestring,deepseq,deepseq-generics,vector,parallel,monad-parallel,transformers,gnuplot,binary,filepath,directory,vector-binary-instances,unix,temporary

10+ Build-Depends: base,mtl,containers,unordered-containers,parsec,hashable,haskeline,directory,uuid,cassava,text,bytestring,deepseq,deepseq-generics,vector,parallel,monad-parallel,transformers,gnuplot,binary,filepath,directory,vector-binary-instances,unix,temporary,stm

11 Exposed-Modules: ProjectM36.Error,

12 ProjectM36.Transaction,

13 ProjectM36.TransactionGraph,

@@ -27,7 +27,8 @@ Library

27 ProjectM36.StaticOptimizer,

28 ProjectM36.Relation.Show.Term,

29 ProjectM36.Relation.Show.CSV,

30− ProjectM36.Relation.Show.Gnuplot

30+ ProjectM36.Relation.Show.Gnuplot,

31+ ProjectM36.Client

31 GHC-Options: -Wall -rtsopts

32 GHC-Options: -Wall -rtsopts

33Executable tutd

34Executable tutd

test/TutorialD/Interpreter.hs+75−81

@@ -1,6 +1,7 @@

1{-# LANGUAGE OverloadedStrings #-}

2import TutorialD.Interpreter.DatabaseExpr

3import TutorialD.Interpreter

4+import TutorialD.Interpreter.Base

4import Test.HUnit

5import Test.HUnit

5import ProjectM36.RelationalExpression

6import ProjectM36.RelationalExpression

6import ProjectM36.Relation

7import ProjectM36.Relation

@@ -8,16 +9,14 @@ import ProjectM36.Tuple

8import ProjectM36.TupleSet

9import ProjectM36.TupleSet

9import ProjectM36.Error

10import ProjectM36.Error

10import ProjectM36.Base

11import ProjectM36.Base

11−import ProjectM36.Transaction

12import ProjectM36.TransactionGraph

13+import ProjectM36.Client

13import qualified ProjectM36.Attribute as A

14import qualified ProjectM36.Attribute as A

14import qualified Data.HashSet as HS

15import qualified Data.HashSet as HS

15import qualified Data.Map as M

16import qualified Data.Map as M

16−import qualified Data.Set as S

17import System.Exit

18−import Data.UUID.V4 (nextRandom)

18+import Data.Maybe (isJust)

19−import Data.UUID (nil)

19+import System.IO

20−import Data.Either (isRight)

21import qualified Data.Vector as V

20import qualified Data.Vector as V

23--urgent: add group and ungroup tests- I missed the group relation type bug

22--urgent: add group and ungroup tests- I missed the group relation type bug

@@ -105,91 +104,78 @@ assertTutdEqual databaseContext expected tutd = assertEqual tutd expected interp

105

104

106transactionGraphBasicTest :: Test

105transactionGraphBasicTest :: Test

107transactionGraphBasicTest = TestCase $ do

106transactionGraphBasicTest = TestCase $ do

108− (_, graph) <- dateExamplesGraph

107+ dbconn <- dateExamplesConnection

108+ graph <- transactionGraph dbconn

109− assertEqual "validate bootstrapped graph" (validateGraph graph) Nothing

109+ assertEqual "validate bootstrapped graph" (validateGraph graph) Nothing

110

111--add a new transaction to the graph, validate it is in the graph

112transactionGraphAddCommitTest :: Test

113transactionGraphAddCommitTest = TestCase $ do

114− ((DisconnectedTransaction firstUUID context), origGraph) <- dateExamplesGraph

114+ dbconn <- dateExamplesConnection

115− freshUUID <- nextRandom

115+ case parseTutorialD dbconn "x:=S" of

116− case interpretDatabaseExpr context "x:=S" of

117− Left err -> assertFailure (show err)

116+ Left err -> assertFailure (show err)

118− Right newContext -> do

117+ Right parsed -> do

119− let discon = newDisconnectedTransaction firstUUID newContext

118+ result <- evalTutorialD dbconn parsed

120− let addTrans = addDisconnectedTransaction freshUUID "master" discon origGraph

119+ case result of

121− case addTrans of

120+ QuitResult -> assertFailure "quit?"

121+ DisplayResult _ -> assertFailure "display?"

122+ DisplayIOResult _ -> assertFailure "displayIO?"

122− Left err -> assertFailure (show err)

123+ DisplayErrorResult err -> assertFailure (show err)

123− Right (newTrans, graph) -> do

124+ QuietSuccessResult -> do

124− assertBool "transaction in graph" (isRight $ transactionForUUID freshUUID graph)

125+ commit dbconn >>= maybeFail

125− assertEqual "validate fresh commit with deleted S" (validateGraph graph) Nothing

126+ (DisconnectedTransaction _ context) <- disconnectedTransaction dbconn

126− assertEqual "ensure S was deleted in newContext" (M.lookup "x" (relationVariables (transactionContext newTrans))) (Just suppliersRel)

127+ assertEqual "ensure x was added" (M.lookup "x" (relationVariables context)) (Just suppliersRel)

127

128

128transactionRollbackTest :: Test

129transactionRollbackTest :: Test

129transactionRollbackTest = TestCase $ do

130transactionRollbackTest = TestCase $ do

130− ((DisconnectedTransaction firstUUID origContext), graph) <- dateExamplesGraph

131+ dbconn <- dateExamplesConnection

131− freshUUID <- nextRandom

132+ graph <- transactionGraph dbconn

132− case transactionForUUID firstUUID graph of

133+ maybeErr <- executeDatabaseContextExpr dbconn (Assign "x" (RelationVariable "S"))

133− Left err -> assertFailure (show err)

134+ case maybeErr of

134− Right _ -> do

135− case interpretDatabaseExpr origContext "x:=S" of

136− Left err -> assertFailure (show err)

135+ Just err -> assertFailure (show err)

137− Right newContext -> do

136+ Nothing -> do

138− let discon = newDisconnectedTransaction firstUUID newContext

137+ rollback dbconn >>= maybeFail

139− let (_, (DisconnectedTransaction _ newContext2), newGraph, _) = interpret freshUUID discon graph ":rollback"

138+ (DisconnectedTransaction _ context') <- disconnectedTransaction dbconn

139+ graph' <- transactionGraph dbconn

140− assertEqual "validate context" (M.lookup "x" (relationVariables newContext2)) Nothing

140+ assertEqual "validate context" Nothing (M.lookup "x" (relationVariables context'))

141− assertEqual "validate graph" graph newGraph

141+ assertEqual "validate graph" graph graph'

142

143--commit a new transaction with "x" relation, jump to first transaction, verify that "x" is not present

144transactionJumpTest :: Test

145transactionJumpTest = TestCase $ do

146+ dbconn <- dateExamplesConnection

146− ((DisconnectedTransaction firstUUID origContext), origGraph) <- dateExamplesGraph

147+ (DisconnectedTransaction firstUUID _) <- disconnectedTransaction dbconn

147− freshUUID <- nextRandom

148+ maybeErr <- executeDatabaseContextExpr dbconn (Assign "x" (RelationVariable "S"))

148− case transactionForUUID firstUUID origGraph of

149+ case maybeErr of

149− Left err -> assertFailure (show err)

150− Right _ -> do

151− case interpretDatabaseExpr origContext "x:=S" of

152− Left err -> assertFailure (show err)

153− Right newContext -> do

154− --modify the second transaction

155− case interpretDatabaseExpr newContext "x:=S" of

156− Left err-> assertFailure (show err)

150+ Just err -> assertFailure (show err)

157− Right newContext2 -> do

151+ Nothing -> do

158− --add the transaction

152+ commit dbconn >>= maybeFail

159− let discon = newDisconnectedTransaction firstUUID newContext2

153+ --perform the jump

160− let addTrans = addDisconnectedTransaction freshUUID "master" discon origGraph

154+ maybeErr2 <- executeGraphExpr dbconn (JumpToTransaction firstUUID)

161− case addTrans of

155+ case maybeErr2 of

162− Left err -> assertFailure (show err)

156+ Just err -> assertFailure (show err)

163− Right (_, graph) -> do

157+ Nothing -> do

164− --jump to the first transaction

158+ --check that the disconnected transaction does not include "x"

165− let (_, (DisconnectedTransaction parentUUID newContext3), newGraph, _) = interpret freshUUID discon graph (":jump " ++ show firstUUID)

159+ (DisconnectedTransaction _ context') <- disconnectedTransaction dbconn

166− assertEqual "validate discon" parentUUID firstUUID

167− assertEqual "validate discon2" Nothing (M.lookup "x" (relationVariables newContext3))

160+ assertEqual "ensure x is not present" Nothing (M.lookup "x" (relationVariables context'))

168− assertEqual "validate graph" transactionUUIDs (S.map transactionUUID (transactionsForGraph newGraph))

161+

169− where

162+maybeFail :: (Show a) => Maybe a -> IO ()

170− transactionUUIDs = S.fromList [firstUUID, freshUUID]

163+maybeFail (Just err) = assertFailure (show err)

164+maybeFail Nothing = return ()

171

165

172--branch from the first transaction and verify that there are two heads

166--branch from the first transaction and verify that there are two heads

173transactionBranchTest :: Test

167transactionBranchTest :: Test

174transactionBranchTest = TestCase $ do

168transactionBranchTest = TestCase $ do

175− (origDiscon@(DisconnectedTransaction firstUUID origContext), origGraph) <- dateExamplesGraph

169+ dbconn <- dateExamplesConnection

176− freshUUID1 <- nextRandom

170+ mapM_ (\x -> x >>= maybeFail) [executeGraphExpr dbconn (Branch "test"),

177− freshUUID2 <- nextRandom

171+ executeDatabaseContextExpr dbconn (Assign "x" (RelationVariable "S")),

178− case transactionForUUID firstUUID origGraph of

172+ commit dbconn,

179− Left err -> assertFailure (show err)

173+ executeGraphExpr dbconn (JumpToHead "master"),

180− Right _ -> do

174+ executeDatabaseContextExpr dbconn (Assign "y" (RelationVariable "S"))

181− let disconMaster = newDisconnectedTransaction firstUUID origContext

175+ ]

182− let addTransMaster = addDisconnectedTransaction freshUUID1 "master" disconMaster origGraph

176+ graph <- transactionGraph dbconn

183− --add a second transaction to the "master" branch

177+ assertBool "master branch exists" $ isJust (transactionForHead "master" graph)

184− case addTransMaster of

178+ assertBool "test branch exists" $ isJust (transactionForHead "test" graph)

185− Left err -> assertFailure (show err)

186− Right (_, graph) -> do

187− --add a third transaction to the "test" branch

188− let (_, _, newGraph, _) = interpret freshUUID2 origDiscon graph ":branch test"

189− assertEqual "verify test head" freshUUID2 $ maybeTransUUID (transactionForHead "test" newGraph)

190− assertEqual "verify master head" freshUUID1 $ maybeTransUUID (transactionForHead "master" newGraph)

191− where

192− maybeTransUUID t = maybe nil transactionUUID t

193

179

194simpleJoinTest :: Test

180simpleJoinTest :: Test

195simpleJoinTest = TestCase $ assertTutdEqual dateExamples joinedRel "x:=S join SP"

181simpleJoinTest = TestCase $ assertTutdEqual dateExamples joinedRel "x:=S join SP"

@@ -214,10 +200,18 @@ simpleJoinTest = TestCase $ assertTutdEqual dateExamples joinedRel "x:=S join SP

214 [StringAtom "London", IntAtom 200, StringAtom "P2", StringAtom "S4", StringAtom "Clark", IntAtom 20]

200 [StringAtom "London", IntAtom 200, StringAtom "P2", StringAtom "S4", StringAtom "Clark", IntAtom 20]

215 ]

201 ]

216

202

217−dateExamplesGraph :: IO (DisconnectedTransaction, TransactionGraph)

203+dateExamplesConnection :: IO (Connection)

218−dateExamplesGraph = do

204+dateExamplesConnection = do

219− firstTransactionUUID <- nextRandom

205+ dbconn <- connectProjectM36 (InProcessConnectionInfo NoPersistence)

220− let graph = bootstrapTransactionGraph firstTransactionUUID dateExamples

206+ case dbconn of

221− let discon = newDisconnectedTransaction firstTransactionUUID dateExamples

207+ Left err -> do

208+ hPutStrLn stderr (show err)

209+ exitFailure

210+ Right conn -> do

211+ mapM_ (\(rvName,rvRel) -> executeDatabaseContextExpr conn (Assign rvName (ExistingRelation rvRel))) (M.toList (relationVariables dateExamples))

212+ mapM_ (\(idName,incDep) -> executeDatabaseContextExpr conn (AddInclusionDependency idName incDep)) (M.toList (inclusionDependencies dateExamples))

213+ --skipping atom functions for now- there are no atom function manipulation operators yet

214+ commit conn >>= maybeFail

222− return (discon, graph)

215+ return conn

216+

223

217