W gąszczu grafów

MATCH (n:Label) RETURN n;
MATCH (n)-[:LIKES]->m return m;
MATCH (n)-[r:LIKES]->m return r;

(a)-->(b)
(a)-->(b)<--(c)
(a:User)-->(b)
(a:User:Admin)-->(b)
(a)-[r:REL_TYPE]->(b)
(a)-[*2]->(b)
(a)-[*3..5]->(b)

MATCH a-[:REL]-b WHERE NOT b-[:REL]-c RETURN b;
MATCH a-[:REL]-b RETURN a,b-[:REL]-c;
MATCH a-[:REL]-b WITH a, b-[:REL]-c RETURN a, count(distinct c);

RETURN [0,1,2,3,4,5,6,7,8,9] AS collection
RETURN range(0,10)[3]
RETURN length(range(0,10)[0..3])
RETURN [x IN range(0,10) WHERE x % 2 = 0 | x^3] AS result

RETURN [x IN range(0,10) WHERE x % 2 = 0 | x^3] AS result;

WHERE a.name='Alice' AND b.name='Daniel' AND
ALL (x IN nodes(p) WHERE x.age > 30);

WHERE a.name='Eskil' AND ANY (x IN a.array WHERE x = "one");

WHERE n.name='Alice' AND NONE (x IN nodes(p) WHERE x.age = 25);

WHERE n.name='Alice' AND
SINGLE (var IN nodes(p) WHERE var.eyes = "blue");

MATCH (n)
WHERE EXISTS(n.name)
RETURN n.name AS name, EXISTS((n)-[:MARRIED]->()) AS is_married

MATCH p = ((a)--(b)) RETURN nodes(p)
MATCH p = ((a)--(b)) RETURN relationships(p)
MATCH p = ((a)-[:RAILS]-(b)) UNWIND nodes(p) AS n return DISTINCT n;

MATCH (david { name: "David" })-(otherPerson)->()
WITH otherPerson, count(*) AS foaf
WHERE foaf > 1
RETURN otherPerson

CREATE
	(t0:Training {title : "Archeologia kodu a architektura" }),
      	(n0:Trainer { name : "Jarosław Pałka"}),
        (s0:Skill { name : "Git" }),
        (s1:Skill { name : "SonarQube"}),
	t0-[:AUTHORED_BY]->n0,
	t0-[:REQUIRES]->s0,
	t0-[:INTRODUCES]->s1;

MATCH (a:Skill {name:"Java"})<-[:REQUIRES]-(b:Training)
MATCH (c:Training)-[:INTRODUCES]->(d:Skill {name:"REST"})
MATCH p=allShortestPaths(b-[rels:REQUIRES|INTRODUCES*]-c)
WHERE length(p)%2=0 AND ALL(idx in range(0, length(p)-2,2) WHERE type(rels[idx])="INTRODUCES" AND type(rels[idx+1]) = "REQUIRES")
RETURN p

EXPLAIN
MATCH (p:Person { name:"Tom Hanks" })
RETURN p

PROFILE
MATCH (p:Person { name:"Tom Hanks" })
RETURN p

CREATE INDEX ON :Message(`In-Reply-To`);
CREATE INDEX ON :Message(`Message-Id`);

neo4j-sh (?)$ schema
Indexes
  ON :Message(In-Reply-To) ONLINE
  ON :Message(Message-Id) ONLINE
No constraints

algorithm tarjan is
  input: graph G = (V, E)
  output: set of strongly connected components (sets of vertices)

  index := 0
  S := empty
  for each v in V do
    if (v.index is undefined) then
      strongconnect(v)
    end if
  end for

  function strongconnect(v)
    // Set the depth index for v to the smallest unused index
    v.index := index
    v.lowlink := index
    index := index + 1
    S.push(v)
    v.onStack := true

    // Consider successors of v
    for each (v, w) in E do
      if (w.index is undefined) then
        // Successor w has not yet been visited; recurse on it
        strongconnect(w)
        v.lowlink  := min(v.lowlink, w.lowlink)
      else if (w.onStack) then
        // Successor w is in stack S and hence in the current SCC
        v.lowlink  := min(v.lowlink, w.index)
      end if
    end for

    // If v is a root node, pop the stack and generate an SCC
    if (v.lowlink = v.index) then
      start a new strongly connected component
      repeat
        w := S.pop()
        w.onStack := false
        add w to current strongly connected component
      until (w = v)
      output the current strongly connected component
    end if
  end function

LOAD CSV FROM 'file:data.csv' AS line  FIELDTERMINATOR '|'
WITH line[0] AS firstname, line[0] AS lastname
CREATE (:Person {firstname : firstname, lastname : lastname});

LOAD CSV WITH HEADERS FROM 'file:data.csv' AS line
CREATE (:Person {firstname : line.firstname, lastname : line.lastname});