{-# LANGUAGE FlexibleInstances #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
--really, a better name for this module could be "TransTransactionGraphRelationalExpr", but that name is too long
module ProjectM36.TransGraphRelationalExpression where
import ProjectM36.Base
import ProjectM36.TransactionGraph
import ProjectM36.Error
import qualified Data.Map as M
import Control.Monad.Trans.Reader
import Control.Monad.Trans.Class
import Control.Monad.Trans.Except
import Data.Functor.Identity

-- | The TransGraphRelationalExpression is equivalent to a relational expression except that relation variables can reference points in the transaction graph (at previous points in time).
type TransGraphRelationalExpr = RelationalExprBase TransactionIdLookup

type TransGraphAttributeNames = AttributeNamesBase TransactionIdLookup

type TransGraphExtendTupleExpr = ExtendTupleExprBase TransactionIdLookup

type TransGraphTupleExpr = TupleExprBase TransactionIdLookup

type TransGraphTupleExprs = TupleExprsBase TransactionIdLookup

type TransGraphRestrictionPredicateExpr = RestrictionPredicateExprBase TransactionIdLookup

type TransGraphAtomExpr = AtomExprBase TransactionIdLookup

type TransGraphAttributeExpr = AttributeExprBase TransactionIdLookup

type TransGraphWithNameExpr = WithNameExprBase TransactionIdLookup

newtype TransGraphEvalEnv = TransGraphEvalEnv {
  TransGraphEvalEnv -> TransactionGraph
tge_graph :: TransactionGraph
  }

type TransGraphEvalMonad a = ReaderT TransGraphEvalEnv (ExceptT RelationalError Identity) a

process :: TransGraphEvalEnv -> TransGraphRelationalExpr -> Either RelationalError GraphRefRelationalExpr
process :: TransGraphEvalEnv
-> TransGraphRelationalExpr
-> Either RelationalError GraphRefRelationalExpr
process TransGraphEvalEnv
env TransGraphRelationalExpr
texpr = forall a. Identity a -> a
runIdentity (forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
texpr) TransGraphEvalEnv
env))

liftE :: Either RelationalError a -> TransGraphEvalMonad a
liftE :: forall a. Either RelationalError a -> TransGraphEvalMonad a
liftE = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
except

askGraph :: TransGraphEvalMonad TransactionGraph
askGraph :: TransGraphEvalMonad TransactionGraph
askGraph = TransGraphEvalEnv -> TransactionGraph
tge_graph forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) r. Monad m => ReaderT r m r
ask

findTransId :: TransactionIdLookup -> TransGraphEvalMonad GraphRefTransactionMarker
findTransId :: TransactionIdLookup
-> TransGraphEvalMonad GraphRefTransactionMarker
findTransId TransactionIdLookup
tlook = TransactionId -> GraphRefTransactionMarker
TransactionMarker forall b c a. (b -> c) -> (a -> b) -> a -> c
. Transaction -> TransactionId
transactionId forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransactionIdLookup -> TransGraphEvalMonad Transaction
findTrans TransactionIdLookup
tlook

findTrans :: TransactionIdLookup -> TransGraphEvalMonad Transaction
findTrans :: TransactionIdLookup -> TransGraphEvalMonad Transaction
findTrans TransactionIdLookup
tlook = do
  TransactionGraph
graph <- TransGraphEvalMonad TransactionGraph
askGraph
  forall a. Either RelationalError a -> TransGraphEvalMonad a
liftE forall a b. (a -> b) -> a -> b
$ TransactionGraph
-> TransactionIdLookup -> Either RelationalError Transaction
lookupTransaction TransactionGraph
graph TransactionIdLookup
tlook

-- OUTDATED a previous attempt at this function attempted to convert TransGraphRelationalExpr to RelationalExpr by resolving the transaction lookups. However, there is no way to resolve a FunctionAtomExpr to an Atom without fully evaluating the higher levels (TupleExpr, etc.). An anonymous function expression cannot be serialized, so that workaround is out. Still, I suspect we can reuse the existing static optimizer logic to work on both structures. The current conversion reduces the chance of whole-query optimization due to full-evaluation on top of full-evaluation, so this function would benefit from some re-design.
processTransGraphRelationalExpr :: TransGraphRelationalExpr -> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr :: TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr (MakeRelationFromExprs Maybe [AttributeExprBase TransactionIdLookup]
mAttrExprs TupleExprsBase TransactionIdLookup
tupleExprs) = do
  GraphRefTupleExprs
tupleExprs' <- TupleExprsBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefTupleExprs
processTransGraphTupleExprs TupleExprsBase TransactionIdLookup
tupleExprs
  case Maybe [AttributeExprBase TransactionIdLookup]
mAttrExprs of
    Maybe [AttributeExprBase TransactionIdLookup]
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a.
Maybe [AttributeExprBase a]
-> TupleExprsBase a -> RelationalExprBase a
MakeRelationFromExprs forall a. Maybe a
Nothing GraphRefTupleExprs
tupleExprs')
    Just [AttributeExprBase TransactionIdLookup]
attrExprs -> do
      [GraphRefAttributeExpr]
attrExprs' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM AttributeExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAttributeExpr
processTransGraphAttributeExpr [AttributeExprBase TransactionIdLookup]
attrExprs
      forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a.
Maybe [AttributeExprBase a]
-> TupleExprsBase a -> RelationalExprBase a
MakeRelationFromExprs (forall a. a -> Maybe a
Just [GraphRefAttributeExpr]
attrExprs') GraphRefTupleExprs
tupleExprs')
processTransGraphRelationalExpr (MakeStaticRelation Attributes
attrs RelationTupleSet
tupSet) = forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a. Attributes -> RelationTupleSet -> RelationalExprBase a
MakeStaticRelation Attributes
attrs RelationTupleSet
tupSet)
processTransGraphRelationalExpr (ExistingRelation Relation
rel) = forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a. Relation -> RelationalExprBase a
ExistingRelation Relation
rel)
processTransGraphRelationalExpr (RelationValuedAttribute AttributeName
attrName) = forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a. AttributeName -> RelationalExprBase a
RelationValuedAttribute AttributeName
attrName)
processTransGraphRelationalExpr (RelationVariable AttributeName
rvname TransactionIdLookup
transLookup) = 
  forall a. AttributeName -> a -> RelationalExprBase a
RelationVariable AttributeName
rvname forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransactionIdLookup
-> TransGraphEvalMonad GraphRefTransactionMarker
findTransId TransactionIdLookup
transLookup
processTransGraphRelationalExpr (Project AttributeNamesBase TransactionIdLookup
transAttrNames TransGraphRelationalExpr
expr) = 
  forall a.
AttributeNamesBase a
-> RelationalExprBase a -> RelationalExprBase a
Project forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AttributeNamesBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAttributeNames
processTransGraphAttributeNames AttributeNamesBase TransactionIdLookup
transAttrNames forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
expr
processTransGraphRelationalExpr (Union TransGraphRelationalExpr
exprA TransGraphRelationalExpr
exprB) =
  forall a.
RelationalExprBase a
-> RelationalExprBase a -> RelationalExprBase a
Union forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
exprA forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
exprB
processTransGraphRelationalExpr (Join TransGraphRelationalExpr
exprA TransGraphRelationalExpr
exprB) =
  forall a.
RelationalExprBase a
-> RelationalExprBase a -> RelationalExprBase a
Join forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
exprA forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
exprB
processTransGraphRelationalExpr (Rename Set (AttributeName, AttributeName)
attrs TransGraphRelationalExpr
expr) =
  forall a.
Set (AttributeName, AttributeName)
-> RelationalExprBase a -> RelationalExprBase a
Rename Set (AttributeName, AttributeName)
attrs forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
expr
processTransGraphRelationalExpr (Difference TransGraphRelationalExpr
exprA TransGraphRelationalExpr
exprB) =
  forall a.
RelationalExprBase a
-> RelationalExprBase a -> RelationalExprBase a
Difference forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
exprA forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
exprB
processTransGraphRelationalExpr (Group AttributeNamesBase TransactionIdLookup
transAttrNames AttributeName
attrName TransGraphRelationalExpr
expr) = 
  forall a.
AttributeNamesBase a
-> AttributeName -> RelationalExprBase a -> RelationalExprBase a
Group forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    AttributeNamesBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAttributeNames
processTransGraphAttributeNames AttributeNamesBase TransactionIdLookup
transAttrNames forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    forall (f :: * -> *) a. Applicative f => a -> f a
pure AttributeName
attrName forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
expr
processTransGraphRelationalExpr (Ungroup AttributeName
attrName TransGraphRelationalExpr
expr) = 
  forall a.
AttributeName -> RelationalExprBase a -> RelationalExprBase a
Ungroup AttributeName
attrName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
expr
processTransGraphRelationalExpr (Restrict RestrictionPredicateExprBase TransactionIdLookup
predicateExpr TransGraphRelationalExpr
expr) =
  forall a.
RestrictionPredicateExprBase a
-> RelationalExprBase a -> RelationalExprBase a
Restrict forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RestrictionPredicateExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefRestrictionPredicateExpr
evalTransGraphRestrictionPredicateExpr RestrictionPredicateExprBase TransactionIdLookup
predicateExpr forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
expr
processTransGraphRelationalExpr (Equals TransGraphRelationalExpr
exprA TransGraphRelationalExpr
exprB) = do  
  GraphRefRelationalExpr
exprA' <- TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
exprA
  GraphRefRelationalExpr
exprB' <- TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
exprB 
  forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a.
RelationalExprBase a
-> RelationalExprBase a -> RelationalExprBase a
Equals GraphRefRelationalExpr
exprA' GraphRefRelationalExpr
exprB')
processTransGraphRelationalExpr (NotEquals TransGraphRelationalExpr
exprA TransGraphRelationalExpr
exprB) = do  
  GraphRefRelationalExpr
exprA' <- TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
exprA 
  GraphRefRelationalExpr
exprB' <- TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
exprB 
  forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a.
RelationalExprBase a
-> RelationalExprBase a -> RelationalExprBase a
NotEquals GraphRefRelationalExpr
exprA' GraphRefRelationalExpr
exprB')
processTransGraphRelationalExpr (Extend ExtendTupleExprBase TransactionIdLookup
extendExpr TransGraphRelationalExpr
expr) = do
  GraphRefExtendTupleExpr
extendExpr' <- ExtendTupleExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefExtendTupleExpr
processTransGraphExtendTupleExpr ExtendTupleExprBase TransactionIdLookup
extendExpr 
  GraphRefRelationalExpr
expr' <- TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
expr 
  forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a.
ExtendTupleExprBase a
-> RelationalExprBase a -> RelationalExprBase a
Extend GraphRefExtendTupleExpr
extendExpr' GraphRefRelationalExpr
expr')
processTransGraphRelationalExpr (With WithNamesAssocsBase TransactionIdLookup
views TransGraphRelationalExpr
expr) = do
  [(GraphRefWithNameExpr, GraphRefRelationalExpr)]
evaldViews <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (\(TransGraphWithNameExpr
wnexpr, TransGraphRelationalExpr
vexpr) -> do
                         GraphRefWithNameExpr
wnexpr' <- TransGraphWithNameExpr -> TransGraphEvalMonad GraphRefWithNameExpr
processTransGraphWithNameExpr TransGraphWithNameExpr
wnexpr
                         GraphRefRelationalExpr
vexpr' <- TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
vexpr 
                         forall (f :: * -> *) a. Applicative f => a -> f a
pure (GraphRefWithNameExpr
wnexpr', GraphRefRelationalExpr
vexpr')
                     ) WithNamesAssocsBase TransactionIdLookup
views
  GraphRefRelationalExpr
expr' <- TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
expr 
  forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a.
WithNamesAssocsBase a
-> RelationalExprBase a -> RelationalExprBase a
With [(GraphRefWithNameExpr, GraphRefRelationalExpr)]
evaldViews GraphRefRelationalExpr
expr')

processTransGraphTupleExprs :: TransGraphTupleExprs -> TransGraphEvalMonad GraphRefTupleExprs
processTransGraphTupleExprs :: TupleExprsBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefTupleExprs
processTransGraphTupleExprs (TupleExprs TransactionIdLookup
marker [TupleExprBase TransactionIdLookup]
texprs) =
  forall a. a -> [TupleExprBase a] -> TupleExprsBase a
TupleExprs forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransactionIdLookup
-> TransGraphEvalMonad GraphRefTransactionMarker
findTransId TransactionIdLookup
marker forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM TupleExprBase TransactionIdLookup
-> TransGraphEvalMonad (TupleExprBase GraphRefTransactionMarker)
processTransGraphTupleExpr [TupleExprBase TransactionIdLookup]
texprs

processTransGraphTupleExpr :: TransGraphTupleExpr -> TransGraphEvalMonad GraphRefTupleExpr
processTransGraphTupleExpr :: TupleExprBase TransactionIdLookup
-> TransGraphEvalMonad (TupleExprBase GraphRefTransactionMarker)
processTransGraphTupleExpr (TupleExpr Map AttributeName (AtomExprBase TransactionIdLookup)
attrMap) = do
  let attrAssoc :: ReaderT
  TransGraphEvalEnv
  (ExceptT RelationalError Identity)
  [(AttributeName, GraphRefAtomExpr)]
attrAssoc = forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (\(AttributeName
attrName, AtomExprBase TransactionIdLookup
atomExpr) -> do 
                        GraphRefAtomExpr
aExpr <- AtomExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAtomExpr
processTransGraphAtomExpr AtomExprBase TransactionIdLookup
atomExpr
                        forall (f :: * -> *) a. Applicative f => a -> f a
pure (AttributeName
attrName, GraphRefAtomExpr
aExpr)
                    ) (forall k a. Map k a -> [(k, a)]
M.toList Map AttributeName (AtomExprBase TransactionIdLookup)
attrMap)
  forall a. Map AttributeName (AtomExprBase a) -> TupleExprBase a
TupleExpr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Ord k => [(k, a)] -> Map k a
M.fromList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReaderT
  TransGraphEvalEnv
  (ExceptT RelationalError Identity)
  [(AttributeName, GraphRefAtomExpr)]
attrAssoc
  
processTransGraphAtomExpr :: TransGraphAtomExpr -> TransGraphEvalMonad GraphRefAtomExpr
processTransGraphAtomExpr :: AtomExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAtomExpr
processTransGraphAtomExpr (AttributeAtomExpr AttributeName
aname) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. AttributeName -> AtomExprBase a
AttributeAtomExpr AttributeName
aname
processTransGraphAtomExpr (SubrelationAttributeAtomExpr AttributeName
relAttr AttributeName
subAttr) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. AttributeName -> AttributeName -> AtomExprBase a
SubrelationAttributeAtomExpr AttributeName
relAttr AttributeName
subAttr
processTransGraphAtomExpr (NakedAtomExpr Atom
atom) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. Atom -> AtomExprBase a
NakedAtomExpr Atom
atom
processTransGraphAtomExpr (FunctionAtomExpr AttributeName
funcName' [AtomExprBase TransactionIdLookup]
args TransactionIdLookup
tLookup) =
  forall a. AttributeName -> [AtomExprBase a] -> a -> AtomExprBase a
FunctionAtomExpr AttributeName
funcName' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM AtomExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAtomExpr
processTransGraphAtomExpr [AtomExprBase TransactionIdLookup]
args forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TransactionIdLookup
-> TransGraphEvalMonad GraphRefTransactionMarker
findTransId TransactionIdLookup
tLookup
processTransGraphAtomExpr (RelationAtomExpr TransGraphRelationalExpr
expr) =
  forall a. RelationalExprBase a -> AtomExprBase a
RelationAtomExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
expr
processTransGraphAtomExpr (IfThenAtomExpr AtomExprBase TransactionIdLookup
ifE AtomExprBase TransactionIdLookup
thenE AtomExprBase TransactionIdLookup
elseE) =
  forall a.
AtomExprBase a
-> AtomExprBase a -> AtomExprBase a -> AtomExprBase a
IfThenAtomExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AtomExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAtomExpr
processTransGraphAtomExpr AtomExprBase TransactionIdLookup
ifE forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AtomExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAtomExpr
processTransGraphAtomExpr AtomExprBase TransactionIdLookup
thenE forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AtomExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAtomExpr
processTransGraphAtomExpr AtomExprBase TransactionIdLookup
elseE
processTransGraphAtomExpr (ConstructedAtomExpr AttributeName
dConsName [AtomExprBase TransactionIdLookup]
args TransactionIdLookup
tLookup) =
  forall a. AttributeName -> [AtomExprBase a] -> a -> AtomExprBase a
ConstructedAtomExpr AttributeName
dConsName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM AtomExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAtomExpr
processTransGraphAtomExpr [AtomExprBase TransactionIdLookup]
args forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TransactionIdLookup
-> TransGraphEvalMonad GraphRefTransactionMarker
findTransId TransactionIdLookup
tLookup
evalTransGraphRestrictionPredicateExpr :: TransGraphRestrictionPredicateExpr -> TransGraphEvalMonad GraphRefRestrictionPredicateExpr
evalTransGraphRestrictionPredicateExpr :: RestrictionPredicateExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefRestrictionPredicateExpr
evalTransGraphRestrictionPredicateExpr RestrictionPredicateExprBase TransactionIdLookup
TruePredicate = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. RestrictionPredicateExprBase a
TruePredicate
evalTransGraphRestrictionPredicateExpr (AndPredicate RestrictionPredicateExprBase TransactionIdLookup
exprA RestrictionPredicateExprBase TransactionIdLookup
exprB) = do
  GraphRefRestrictionPredicateExpr
exprA' <- RestrictionPredicateExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefRestrictionPredicateExpr
evalTransGraphRestrictionPredicateExpr RestrictionPredicateExprBase TransactionIdLookup
exprA
  GraphRefRestrictionPredicateExpr
exprB' <- RestrictionPredicateExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefRestrictionPredicateExpr
evalTransGraphRestrictionPredicateExpr RestrictionPredicateExprBase TransactionIdLookup
exprB
  forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a.
RestrictionPredicateExprBase a
-> RestrictionPredicateExprBase a -> RestrictionPredicateExprBase a
AndPredicate GraphRefRestrictionPredicateExpr
exprA' GraphRefRestrictionPredicateExpr
exprB')
evalTransGraphRestrictionPredicateExpr (OrPredicate RestrictionPredicateExprBase TransactionIdLookup
exprA RestrictionPredicateExprBase TransactionIdLookup
exprB) = do  
  GraphRefRestrictionPredicateExpr
exprA' <- RestrictionPredicateExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefRestrictionPredicateExpr
evalTransGraphRestrictionPredicateExpr RestrictionPredicateExprBase TransactionIdLookup
exprA 
  GraphRefRestrictionPredicateExpr
exprB' <- RestrictionPredicateExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefRestrictionPredicateExpr
evalTransGraphRestrictionPredicateExpr RestrictionPredicateExprBase TransactionIdLookup
exprB
  forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a.
RestrictionPredicateExprBase a
-> RestrictionPredicateExprBase a -> RestrictionPredicateExprBase a
OrPredicate GraphRefRestrictionPredicateExpr
exprA' GraphRefRestrictionPredicateExpr
exprB')
evalTransGraphRestrictionPredicateExpr (NotPredicate RestrictionPredicateExprBase TransactionIdLookup
expr) = do
  let expr' :: TransGraphEvalMonad GraphRefRestrictionPredicateExpr
expr' = RestrictionPredicateExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefRestrictionPredicateExpr
evalTransGraphRestrictionPredicateExpr RestrictionPredicateExprBase TransactionIdLookup
expr
  forall a.
RestrictionPredicateExprBase a -> RestrictionPredicateExprBase a
NotPredicate forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransGraphEvalMonad GraphRefRestrictionPredicateExpr
expr'
evalTransGraphRestrictionPredicateExpr (RelationalExprPredicate TransGraphRelationalExpr
expr) = do  
  let expr' :: TransGraphEvalMonad GraphRefRelationalExpr
expr' = TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
expr
  forall a. RelationalExprBase a -> RestrictionPredicateExprBase a
RelationalExprPredicate forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransGraphEvalMonad GraphRefRelationalExpr
expr'
evalTransGraphRestrictionPredicateExpr (AtomExprPredicate AtomExprBase TransactionIdLookup
expr) = do
  let expr' :: TransGraphEvalMonad GraphRefAtomExpr
expr' = AtomExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAtomExpr
processTransGraphAtomExpr AtomExprBase TransactionIdLookup
expr
  forall a. AtomExprBase a -> RestrictionPredicateExprBase a
AtomExprPredicate forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransGraphEvalMonad GraphRefAtomExpr
expr'
evalTransGraphRestrictionPredicateExpr (AttributeEqualityPredicate AttributeName
attrName AtomExprBase TransactionIdLookup
expr) = do  
  let expr' :: TransGraphEvalMonad GraphRefAtomExpr
expr' = AtomExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAtomExpr
processTransGraphAtomExpr AtomExprBase TransactionIdLookup
expr
  forall a.
AttributeName -> AtomExprBase a -> RestrictionPredicateExprBase a
AttributeEqualityPredicate AttributeName
attrName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransGraphEvalMonad GraphRefAtomExpr
expr'
  
processTransGraphExtendTupleExpr :: TransGraphExtendTupleExpr -> TransGraphEvalMonad GraphRefExtendTupleExpr
processTransGraphExtendTupleExpr :: ExtendTupleExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefExtendTupleExpr
processTransGraphExtendTupleExpr (AttributeExtendTupleExpr AttributeName
attrName AtomExprBase TransactionIdLookup
expr) =
  forall a. AttributeName -> AtomExprBase a -> ExtendTupleExprBase a
AttributeExtendTupleExpr AttributeName
attrName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AtomExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAtomExpr
processTransGraphAtomExpr AtomExprBase TransactionIdLookup
expr

processTransGraphAttributeExpr :: TransGraphAttributeExpr -> TransGraphEvalMonad GraphRefAttributeExpr
processTransGraphAttributeExpr :: AttributeExprBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAttributeExpr
processTransGraphAttributeExpr (AttributeAndTypeNameExpr AttributeName
attrName TypeConstructor
tCons TransactionIdLookup
tLookup) =
  forall a.
AttributeName -> TypeConstructor -> a -> AttributeExprBase a
AttributeAndTypeNameExpr AttributeName
attrName TypeConstructor
tCons forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransactionIdLookup
-> TransGraphEvalMonad GraphRefTransactionMarker
findTransId TransactionIdLookup
tLookup
processTransGraphAttributeExpr (NakedAttributeExpr Attribute
attr) = forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a. Attribute -> AttributeExprBase a
NakedAttributeExpr Attribute
attr)  

processTransGraphAttributeNames :: TransGraphAttributeNames -> TransGraphEvalMonad GraphRefAttributeNames
processTransGraphAttributeNames :: AttributeNamesBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAttributeNames
processTransGraphAttributeNames (AttributeNames Set AttributeName
names) = forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a. Set AttributeName -> AttributeNamesBase a
AttributeNames Set AttributeName
names)
processTransGraphAttributeNames (InvertedAttributeNames Set AttributeName
names) = forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a. Set AttributeName -> AttributeNamesBase a
InvertedAttributeNames Set AttributeName
names)
processTransGraphAttributeNames (UnionAttributeNames AttributeNamesBase TransactionIdLookup
namesA AttributeNamesBase TransactionIdLookup
namesB) = do
  GraphRefAttributeNames
nA <- AttributeNamesBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAttributeNames
processTransGraphAttributeNames AttributeNamesBase TransactionIdLookup
namesA 
  GraphRefAttributeNames
nB <- AttributeNamesBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAttributeNames
processTransGraphAttributeNames AttributeNamesBase TransactionIdLookup
namesB
  forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a.
AttributeNamesBase a
-> AttributeNamesBase a -> AttributeNamesBase a
UnionAttributeNames GraphRefAttributeNames
nA GraphRefAttributeNames
nB)
processTransGraphAttributeNames (IntersectAttributeNames AttributeNamesBase TransactionIdLookup
namesA AttributeNamesBase TransactionIdLookup
namesB) = do
  GraphRefAttributeNames
nA <- AttributeNamesBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAttributeNames
processTransGraphAttributeNames AttributeNamesBase TransactionIdLookup
namesA 
  GraphRefAttributeNames
nB <- AttributeNamesBase TransactionIdLookup
-> TransGraphEvalMonad GraphRefAttributeNames
processTransGraphAttributeNames AttributeNamesBase TransactionIdLookup
namesB 
  forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a.
AttributeNamesBase a
-> AttributeNamesBase a -> AttributeNamesBase a
IntersectAttributeNames GraphRefAttributeNames
nA GraphRefAttributeNames
nB)
processTransGraphAttributeNames (RelationalExprAttributeNames TransGraphRelationalExpr
expr) = do
  GraphRefRelationalExpr
evaldExpr <- TransGraphRelationalExpr
-> TransGraphEvalMonad GraphRefRelationalExpr
processTransGraphRelationalExpr TransGraphRelationalExpr
expr 
  forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a. RelationalExprBase a -> AttributeNamesBase a
RelationalExprAttributeNames GraphRefRelationalExpr
evaldExpr)

processTransGraphWithNameExpr :: TransGraphWithNameExpr -> TransGraphEvalMonad GraphRefWithNameExpr
processTransGraphWithNameExpr :: TransGraphWithNameExpr -> TransGraphEvalMonad GraphRefWithNameExpr
processTransGraphWithNameExpr (WithNameExpr AttributeName
rvname TransactionIdLookup
tlookup) =
  forall a. AttributeName -> a -> WithNameExprBase a
WithNameExpr AttributeName
rvname forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TransactionIdLookup
-> TransGraphEvalMonad GraphRefTransactionMarker
findTransId TransactionIdLookup
tlookup