Database.Neo4j.Transactional.Cypher

Module to provide Cypher support using the transactional endpoint.

Example:

 import qualified Database.Neo4j.Transactional.Cypher as T

 withConnection host port $ do
    ...
    res <- TC.runTransaction $ do
            -- Queries return a result with columns, rows, a list of graphs and stats
            result <- TC.cypher "CREATE (pere: PERSON {age: {age}}) CREATE (pau: PERSON {props}) \
                              \CREATE p1 = (pere)-[:KNOWS]->(pau) RETURN pere, pau, p1, pere.age" $
                                M.fromList [("age", TC.newparam (78 :: Int64)),
                                            ("props", TC.ParamProperties $ M.fromList["age" |: (99 :: Int64)])]
            -- if any of the commands returns an error the transaction is rollbacked and leaves
            result 2 <- T.cypher "not a command" M.empty
            void $ TC.cypher "CREATE (pep: PERSON {age: 55})" M.empty
            -- Transactions are implicitly commited/rollbacked (in case of exception)
            -- but can be explicitly committed and rollbacked
            return (result, result2)

Types

data Result

Type for a Cypher response with tuples containing column name and their values

Constructors

Result

Fields

cols :: [Text]

vals :: [[Value]]

graph :: [Graph]

stats :: Stats

Instances

Eq Result

Show Result

FromJSON Result

How to create a response object from a cypher JSON response

data Stats

Holds the connection stats

Constructors

Stats

Fields

containsUpdates :: Bool

nodesCreated :: Integer

nodesDeleted :: Integer

propsSet :: Integer

relsCreated :: Integer

relsDeleted :: Integer

lblsAdded :: Integer

lblsRemoved :: Integer

idxAdded :: Integer

idxRemoved :: Integer

constAdded :: Integer

constRemoved :: Integer

Instances

Eq Stats

Show Stats

FromJSON Stats

Instance to parse stats from a JSON

data ParamValue

Value for a cypher parmeter value, might be a literal, a property map or a list of property maps

Constructors

ParamLiteral PropertyValue

ParamProperties Properties

ParamPropertiesArray [Properties]

Instances

Eq ParamValue

Show ParamValue

ToJSON ParamValue

Instance toJSON for param values so we can serialize them in queries

type Params = HashMap Text ParamValue

We use hashmaps to represent Cypher parameters

newparam :: PropertyValueConstructor a => a -> ParamValue

emptyStats :: Stats

Default stats

type TransError = (Text, Text)

Error code and message for a transaction error

type Transaction a = ExceptT TransError (ReaderT Connection (StateT TransState (ResourceT IO))) a

Sending queries

loneQuery :: Text -> Params -> Neo4j (Either TransError Result)

runTransaction :: Transaction a -> Neo4j (Either TransError a)

Run a transaction and get its final result, has an implicit commit request (or rollback if an exception occurred). This implicit commit/rollback will only be executed if it hasn't before because of an explicit one

cypher :: Text -> Params -> Transaction Result

Run a cypher query in a transaction, if an error occurs the transaction will stop and rollback

rollback :: Transaction ()

Rollback a transaction. After this, executing rollback, commit, keepalive, cypher in the transaction will result in an exception

commit :: Transaction ()

Commit a transaction. After this, executing rollback, commit, keepalive, cypher in the transaction will result in an exception

keepalive :: Transaction ()

Send a keep alive message to an open transaction

commitWith :: Text -> Params -> Transaction Result

Send a cypher query and commit at the same time, if an error occurs the transaction will be rolled back. After this, executing rollback, commit, keepalive, cypher in the transaction will result in an exception

rollbackAndLeave :: Text -> Transaction ()

Rollback a transaction and stop processing it, set the message that runTransaction will return as error

Aux functions

isSuccess :: Either TransError Result -> Bool

True if the operation succeeded

fromResult :: Result -> Either TransError Result -> Result

Get the result of the response or a default value

fromSuccess :: Either TransError Result -> Result

Get the result of the response or a default value