memgraph/skills/memgraph-cypher-syntax

MATCH (n:Person {name: "Alice"})-[:KNOWS]->(m) RETURN m;
MATCH (n:Person) WHERE n.age > 30 RETURN n ORDER BY n.age DESC LIMIT 10;
OPTIONAL MATCH (n)-[:LIVES_IN]->(c:City) RETURN n, c;
MATCH (n) RETURN DISTINCT n.name;
UNWIND [1, 2, 3] AS x RETURN x;

CREATE (n:Person {name: "Alice", age: 30});
CREATE (a)-[:KNOWS {since: 2020}]->(b);
MERGE (n:Person {name: "Alice"}) ON CREATE SET n.created = timestamp() ON MATCH SET n.seen = timestamp();
SET n.age = 31;
SET n:Employee;
REMOVE n:Intern;
REMOVE n.temporary;
DELETE r;
DETACH DELETE n;
DROP GRAPH;

WITH n ORDER BY n.name RETURN collect(n.name);
MATCH (a) RETURN a UNION MATCH (b) RETURN b;
FOREACH (x IN [1,2,3] | CREATE (:N {id: x}));

EXPLAIN MATCH (n:Person) RETURN n;
PROFILE MATCH (n:Person {age: 42}) RETURN n;

MATCH (n:Person) RETURN n;
MATCH (n:Person:Employee) RETURN n;       -- ALL labels (AND)
MATCH (n:Country|Person) RETURN n;        -- ANY label (OR)

MATCH (a)-[*1..3]->(b) RETURN a, b;       -- 1 to 3 hops
MATCH (a)-[*2]->(b) RETURN a, b;           -- exactly 2 hops
MATCH p=(a)-[*]->(b) RETURN relationships(p);

MATCH p=(a {name: "A"})-[*BFS]->(b {name: "E"}) RETURN p;
MATCH p=(a)-[r:ROAD *BFS]->(b) RETURN p;

MATCH p=(a {name: "A"})-[*]->(b {name: "E"}) RETURN p;

MATCH p=(a)-[*WSHORTEST (r, n | r.weight) total_weight]->(b) RETURN p, total_weight;
MATCH p=(a)-[*WSHORTEST (r, n | n.cost + coalesce(r.weight, 0)) total]->(b) RETURN p, total;

MATCH p=(a)-[*ALLSHORTEST (r, n | r.weight)]->(b) RETURN p;

MATCH (a:Node {name: "A"}), (b:Node {name: "E"})
WITH a, b
MATCH p=(a)-[*KSHORTEST|3]->(b) RETURN p;

MATCH p=(a)-[*BFS (r, n | r.eu_border = false AND n.drinks < 15)]->(b) RETURN p;

MATCH p=(a)-[* (r, n, p | type(last(relationships(p))) != 'CloseTo')]->(b) RETURN p;

MATCH p=(a)-[*WSHORTEST (r, n | r.weight) total (r, n, p, w | w < 1000)]->(b) RETURN p, total;

MATCH p=(a)-[*BFS ..5]->(b) RETURN p;        -- max 5 hops
MATCH p=(a)-[*WSHORTEST 4 (r, n | r.w)]->(b) RETURN p;
USING HOPS LIMIT 3 MATCH p=(a)-[*BFS]->(b) RETURN p;

MATCH (p:Person)
CALL {
  WITH p
  MATCH (p)-[:KNOWS]->(friend)
  RETURN count(friend) AS friendCount
}
RETURN p.name, friendCount;

CALL (p) {
  MATCH (p)-[:KNOWS]->(f) RETURN count(f) AS cnt
}

LOAD CSV FROM "file.csv" WITH HEADER AS row
CALL {
  WITH row
  CREATE (:Node {id: row.id})
} IN TRANSACTIONS OF 1000 ROWS;

LOAD CSV FROM "/path/file.csv" WITH HEADER AS row
CREATE (:Person {name: row.Name, age: toInteger(row.Age)});
 
LOAD CSV FROM "https://example.com/data.csv" WITH HEADER IGNORE BAD DELIMITER "|" AS row
CREATE (:Node {id: row.id});
 
LOAD PARQUET FROM "/path/file.parquet" AS row CREATE (:Node {val: row.value});
LOAD PARQUET FROM "s3://bucket/data.parquet" WITH CONFIG {
  aws_region: "us-east-1", aws_access_key: $key, aws_secret_key: $secret
} AS row CREATE (:Node {val: row.value});

USING PERIODIC COMMIT 1000
LOAD CSV FROM "/data.csv" WITH HEADER AS row
CREATE (:Node {id: row.id});

MATCH (n:Person {name: $name}) RETURN n;
MATCH (n) SET n.value = $newValue;
MATCH (n) RETURN n LIMIT $limit;

MATCH (n:$label) RETURN n;
SET n:$labels;

CREATE (n $propertyMap);

CREATE TEXT INDEX myIdx ON :Article;
CREATE TEXT INDEX myIdx ON :Article(title, body);
CREATE TEXT EDGE INDEX edgeIdx ON :CITES;
 
CALL text_search.search("myIdx", "data.title:GraphRAG") YIELD node, score RETURN node, score;
CALL text_search.search_all("myIdx", "GraphRAG") YIELD node RETURN node;
CALL text_search.regex_search("myIdx", "graph.*") YIELD node RETURN node;
 
DROP TEXT INDEX myIdx;

CREATE VECTOR INDEX vecIdx ON :Article(embedding)
  WITH CONFIG {"dimension": 256, "capacity": 10000, "metric": "cos"};
 
CALL vector_search.search("vecIdx", 10, [0.1, 0.2, ...]) YIELD node, distance, similarity
RETURN node, similarity ORDER BY similarity DESC;
 
SHOW VECTOR INDEX INFO;
DROP VECTOR INDEX vecIdx;

GRANT PARALLEL_EXECUTION TO user;
USING PARALLEL EXECUTION MATCH (n:Person) RETURN count(n);
USING PARALLEL EXECUTION 8 MATCH (n) WHERE n.age > 30 RETURN count(*);

SHOW SCHEMA INFO;
CALL schema.node_type_properties() YIELD nodeType, nodeLabels, propertyName, propertyTypes;
CALL schema.rel_type_properties() YIELD relType, propertyName, propertyTypes;

ENABLE TTL EVERY "1h" AT "03:00:00";
CREATE (:TTL {ttl: timestamp(), name: "temp"});
STOP TTL;
DISABLE TTL;

WHERE n.name STARTS WITH "Al"
WHERE n.name ENDS WITH "son"
WHERE n.name CONTAINS "ice"
WHERE n.name =~ "^A.*e$"

RETURN CASE n.status WHEN "active" THEN "A" WHEN "inactive" THEN "I" ELSE "?" END;
RETURN CASE WHEN n.age < 18 THEN "minor" WHEN n.age >= 65 THEN "senior" ELSE "adult" END;

RETURN [(n)-->(m:Movie) WHERE m.year > 2000 | m.title] AS recentMovies;

RETURN [x IN range(1, 10) WHERE x % 2 = 0 | x * x] AS evenSquares;

WHERE EXISTS { MATCH (n)-[:KNOWS]->(:Person {city: "Berlin"}) }
WHERE NOT EXISTS { MATCH (n)-[:BLOCKED]->() }

USING INDEX :Person(name)
MATCH (n:Person {name: "Alice"}) RETURN n;

ANALYZE GRAPH;
ANALYZE GRAPH ON LABELS :Person, :City;

MATCH path=(a)-[*BFS]->(b) WITH project(path) AS subgraph RETURN subgraph;

MATCH (n:Person) RETURN n.name, n.age;

USING PERIODIC COMMIT 10000 MATCH ()-[r]->() DELETE r;
USING PERIODIC COMMIT 10000 MATCH (n) DELETE n;