1 package de.dlr.shepard.migrations.neo4j;
2
3 import de.dlr.shepard.common.neo4j.NeoConnector;
4 import java.util.Collections;
5 import java.util.List;
6 import java.util.Map;
7 import java.util.stream.StreamSupport;
8 import org.neo4j.cypherdsl.core.Cypher;
9 import org.neo4j.cypherdsl.core.Node;
10 import org.neo4j.cypherdsl.core.PatternElement;
11 import org.neo4j.cypherdsl.core.Relationship;
12 import org.neo4j.cypherdsl.core.Statement;
13 import org.neo4j.ogm.model.Result;
14 import org.neo4j.ogm.session.Session;
15
16 class QueryHelper {
17
18 private static Session session;
19
20 public QueryHelper() {
21 var conn = NeoConnector.getInstance();
22 conn.connect();
23 session = conn.getNeo4jSession();
24 }
25
26 public Result query(Statement statement) {
27 return session.query(statement.getCypher(), Collections.emptyMap());
28 }
29
30 public void queryNoReturn(String cypher) {
31 session.query(cypher, Collections.emptyMap());
32 }
33
34 public void deleteAll(String label) {
35 var node = Cypher.node(label);
36 var st = Cypher.match(node).detachDelete(node).build();
37 queryNoReturn(st.getCypher());
38 }
39
40 public void create(PatternElement... creatable) {
41 var statement = Cypher.create(creatable).build();
42 query(statement);
43 }
44
45 public void merge(PatternElement creatable) {
46 var statement = Cypher.merge(creatable).build();
47 query(statement);
48 }
49
50 public void createRelationshipForExisting(Node from, Node to, String... labels) {
51 from = from.named("from");
52 to = to.named("to");
53 var statement = Cypher.match(from, to).create(from.relationshipTo(to, labels)).build();
54 query(statement);
55 }
56
57 public <T> T create(Node node, Class<T> type) {
58 var statement = Cypher.create(node).returning(node).build();
59 return queryResults(statement, type).getFirst();
60 }
61
62 public List<Object> match(Node node) {
63 return match(node, Object.class);
64 }
65
66 public List<Object> match(Relationship rel, Node toReturn) {
67 var statement = Cypher.match(rel).returning(toReturn).build();
68 return queryResults(statement, Object.class);
69 }
70
71 public <T> List<T> match(Node node, Class<T> type) {
72 var statement = Cypher.match(node).returning(node).build();
73 return queryResults(statement, type);
74 }
75
76 public <T> List<T> queryResults(Statement statement, Class<T> type) {
77 return queryResults(statement.getCypher(), type);
78 }
79
80 public <T> T loadSingle(Long id, Class<T> type) {
81 return session.load(type, id);
82 }
83
84 public List<Object> queryResults(Statement statement) {
85 return queryResults(statement.getCypher(), Object.class);
86 }
87
88 public List<Object> queryResults(String cypherQuery) {
89 return queryResults(cypherQuery, Object.class);
90 }
91
92 public <T> List<T> queryResults(String cypherQuery, Class<T> type) {
93 var result = session.query(cypherQuery, Collections.emptyMap());
94 return StreamSupport.stream(result.spliterator(), false)
95 .map(Map::values)
96 .flatMap(java.util.Collection::stream)
97 .map(type::cast)
98 .toList();
99 }
100 }