queries.yaml

equivalence:
   add:
      cypher: |
         // find s, t nodes
         MERGE (s:_ {id: {source}})
           ON CREATE SET s :_:_VACANT

         MERGE (t:_ {id: {target}})
           ON CREATE SET t :_:_VACANT

         WITH s,t LIMIT 1

         // find current equivalence class representatives (ECR)
         OPTIONAL MATCH (s) <-[:`=`]- (se:`=`)
         OPTIONAL MATCH (t) <-[:`=`]- (te:`=`)
         OPTIONAL MATCH (se) -[a]- ()
         OPTIONAL MATCH (te) -[b]- ()

         WITH s, t, se, te, collect(DISTINCT a) AS as, collect(DISTINCT b) AS bs 

         // wipe the arcs
         FOREACH(a IN as | DELETE a)
         FOREACH(b IN bs | DELETE b)
         
         // delete the old ECRs
         DELETE se, te
         
         // ensure that at this point we have only one row
         WITH s, t LIMIT 1

         // create equivalence class node
         CREATE (eq:`=`)

         // create relation node
         CREATE UNIQUE (s) -[:`«type»`]-> (r:_:_Rel:`«type»` {id: {id}}) -[:`«type»`]-> (t)
           SET r.dataset = {dataset}

         // find all nodes reachable under the equivalence relation
         WITH s, t, r, eq LIMIT 1

         OPTIONAL MATCH (s) -[:`«type»` * 0 .. 4]- (n:_)
            WHERE NOT n:_Rel // skip the relation nodes
            
         WITH s, t, r, eq, collect(DISTINCT n) AS ns LIMIT 1

         // link to new equivalence class representative
         FOREACH (n IN ns |
            CREATE UNIQUE n <-[:`=`]- eq
            CREATE UNIQUE n -[:`=i`]-> eq
         )

         // at this point we collect all members
         RETURN s, t, r, eq, count(ns) AS size LIMIT 1

   remove:
      cypher: |
         // find relation node
         MATCH (r:_:_Rel {id: {id}})
         
         // find source, target nodes
         MATCH (s) -[x:`«type»`]-> (r) -[y:`«type»`]-> (t)
         
         // remove the relation
         DELETE x, y, r

         // ok, wipe the old ECR
         WITH s, t LIMIT 1
         
         // find current equivalence class representatives (ECR)
         OPTIONAL MATCH (s) <-[:`=`]- (se:`=`)
         OPTIONAL MATCH (t) <-[:`=`]- (te:`=`)
         OPTIONAL MATCH (se) -[a]- ()
         OPTIONAL MATCH (te) -[b]- ()

         WITH s, t, se, te, collect(DISTINCT a) AS as, collect(DISTINCT b) AS bs 

         // wipe the arcs
         FOREACH(a IN as | DELETE a)
         FOREACH(b IN bs | DELETE b)
         
         // delete the old ECRs
         DELETE se, te
         
         // ensure that at this point we have only one row
         WITH s, t LIMIT 1

         // create equivalence class nodes for s and t
         MERGE (s) <-[:`=`]- (se:`=`)
         MERGE (t) <-[:`=`]- (te:`=`)

         WITH s, t, se, te LIMIT 1
         
         // s-size
         OPTIONAL MATCH (s) -[:`«type»` * 0 .. 4]- (n:_)
             WHERE NOT n:_Rel // skip the relation nodes

         WITH s, t, se, te, collect(DISTINCT n) AS ns LIMIT 1

         // link to new equivalence class representative
         FOREACH (n IN ns |
            CREATE UNIQUE n <-[:`=`]- se
            CREATE UNIQUE n -[:`=i`]-> se
         )

         WITH s, t, se, te, count(ns) AS s_size LIMIT 1
         
         OPTIONAL MATCH (t) -[:`«type»` * 0 .. 4]- (n:_)
             WHERE NOT n:_Rel // skip the relation nodes

         WITH s, t, se, te, s_size, collect(DISTINCT n) AS ns LIMIT 1

         // link to new equivalence class representative
         FOREACH (n IN ns |
            CREATE UNIQUE n <-[:`=`]- te
            CREATE UNIQUE n -[:`=i`]-> te
         )

         // at this point we collect all members
         RETURN s, t, se, te, s_size, count(ns) AS t_size LIMIT 1

node:
   add:
      ruleset:
         - '  x  => (*) '
         - ' ( ) => (*) '
         - ' (*) => 500 '
      cypher: |
         MERGE (n:_ {id: {id}})
         ON CREATE
            SET n = {data},
                n.created = timestamp(),
                n.id = {id},
                n.dataset = {dataset},
                n:`«type»`
         ON MATCH
            SET n = {data},
                n.accessTime = timestamp(),
                n.counter = coalesce(n.counter, 0) + 1,
                n.id = {id},
                n.dataset = {dataset},
                n:`«type»`
            REMOVE n:_VACANT
         RETURN n
#   update:
#      ruleset:
#         - '  x  => 404 '
#         - ' ( ) => (*) '
#         - ' (*) => (*) '
#      cypher: |
#         MATCH (n:_ {id: {id}})
#         WITH n, coalesce(n.counter, 0) + 1 AS c
#         SET n = {data},
#             n.accessTime = timestamp(),
#             n.counter = c,
#             n.id = {id},
#             n.dataset = {dataset}
#         RETURN n
   remove:
      ruleset:
         - '    x  => 404   '
         - ' --( ) => 404   '
         - '   (*) => x     '
         - ' --(*) => --( ) '
      cypher: |
         MATCH (n:_ {id: {id}})
         WHERE NOT n:_VACANT
            SET n:_VACANT
            SET n={}
            SET n.id = {id}
            SET n.dataset = {dataset}
         UNION ALL
         OPTIONAL MATCH (n:_:_VACANT {id: {id}})
         WHERE length( (n)--() ) = 0
         DELETE n
         RETURN n
arc:
   add:
      ruleset:
         - '  x   x  => 404        '
         - ' ( )  x   => ( )-->( ) '
         - ' (*)  x   => (*)-->( ) '
         - '  x  ( )  => ( )-->( ) '
         - '  x  (*)  => ( )-->(*) '
         - ' ( ) ( )  => ( )-->( ) '
         - ' (*) ( )  => (*)-->( ) '
         - ' ( ) (*)  => ( )-->(*) '
         - ' (*) (*)  => (*)-->(*) '
      cypher: |
         MERGE (s:_ {id: {source}})
         ON CREATE SET s :_:_VACANT
         MERGE (t:_ {id: {target}})
         ON CREATE SET t :_:_VACANT
         //MERGE (s) <-[:`=`]- (eq1:`=`)
         //MERGE (t) <-[:`=`]- (eq2:`=`)
         WITH s,t LIMIT 1
         CREATE UNIQUE s -[:`«type»`]-> (r:_:_Rel:`«type»` {id: {id}}) -[:`«type»`]-> t
         SET r = {data},
             r.created = timestamp(),
             r.id = {id},
             r.dataset = {dataset}
         //MERGE eq1 -[:`=R` {label: "`«type»`"}]-> eq2
         RETURN s, t, r LIMIT 1
   update:
      ruleset:
         - '    x     x     =>  404         '
         - '   ( )    x     =>  404         '
         - '   (*)    x     =>  404         '
         - '    x    ( )    =>  404         '
         - '    x    (*)    =>  404         '
         - '   ( )-->( )    =>    ( )-->( ) '
         - '   (*)-->( )    =>    (*)-->( ) '
         - '   ( )-->(*)    =>    ( )-->(*) '
         - '   (*)-->(*)    =>    (*)-->(*) '
      cypher: |
         MATCH (s)-[:`«type»`]-(r:_:_Rel:`«type»` {id: {id}})-[:`«type»`]->(t)
         WITH r, coalesce(r.counter, 0) + 1 AS c
         SET r = {data},
             r.accessTime = timestamp(),
             r.counter = c,
             r.id = {id},
             r.dataset = {dataset}
         RETURN r
   remove:
      ruleset:
         - '    x     x     =>  404           '
         - '   ( )    x     =>  404           '
         - '   (*)    x     =>  404           '
         - '    x    ( )    =>  404           '
         - '    x    (*)    =>  404           '
         - '   ( )-->( )    =>     x     x    '
         - '   (*)-->( )    =>    (*)    x    '
         - '   ( )-->(*)    =>     x    (*)   '
         - '   (*)-->(*)    =>    (*)   (*)   '
         - ' --( )-->( )--  =>  --( )   ( )-- '
         - ' --(*)-->( )--  =>  --(*)   ( )-- '
         - ' --( )-->(*)--  =>  --( )   (*)-- '
         - ' --(*)-->(*)--  =>  --(*)   (*)-- '
         - '   ( )-->( )--  =>     x    ( )-- '
         - '   (*)-->( )--  =>    (*)   ( )-- '
         - '   ( )-->(*)--  =>     x    (*)-- '
         - '   (*)-->(*)--  =>    (*)   (*)-- '
         - ' --( )-->( )    =>  --( )    x    '
         - ' --(*)-->( )    =>  --(*)    x    '
         - ' --( )-->(*)    =>  --( )   (*)   '
         - ' --(*)-->(*)    =>  --(*)   (*)   '
      cypher: |
         MATCH (s)-[p:`«type»`]-(r:_:_Rel:`«type»` {id: {id}})-[q:`«type»`]->(t)
            DELETE p,q,r
         WITH s.id AS source, t.id AS target
         OPTIONAL MATCH (n:_:_VACANT)
            WHERE n.id IN [target, source] AND length( (n)-[]-() ) = 0
            DELETE n
         RETURN true
query:
   test:
      cypher: "WITH true AS b RETURN b"
   schema:
      description: Setup Neo4J schema
      cypher: |
         CREATE CONSTRAINT ON (n:_)
         	ASSERT n.id IS UNIQUE
   clear:
      description: Remove all managed nodes and edges
      cypher: |
         OPTIONAL MATCH ()-[e]-() DELETE e
         RETURN DISTINCT true
         UNION
         OPTIONAL MATCH (n) DELETE n
         RETURN DISTINCT true
   graph:
      description: Node and edge list
      cypher: |
         
         // match nodes and return {labels: .., id: ..}
         MATCH (n)
         WITH collect(DISTINCT {
            labels: labels(n),
            id: coalesce(n.id, "neo:" + id(n))
         }) AS nodes LIMIT 1
         
         // match edges and return {s: .., t: ..}
         OPTIONAL MATCH s -[e]-> t
         RETURN nodes, collect(DISTINCT {
           source: coalesce(s.id, "neo:" + id(s)),
           target: coalesce(t.id, "neo:" + id(t))
         }) AS edges LIMIT 1