String query = "MATCH (n:Phone{id:'you'}) MATCH n-[r:calling]->m WHERE n<>m RETURN n, r, m"; ExecutionEngine engine = new ExecutionEngine( db ); ExecutionResult result; try ( Transaction ignored = db.beginTx() ) { result = engine.execute(query); ResourceIterator<Relationship> rels = result.columnAs("r"); while(rels.hasNext()) { Relationship r = rels.next(); // Do something cool here. } } catch(Exception exc) { System.err.println("ERHMAGEHRD!!!"); }
@Override public ExecutionResult execute( final String cypher, final Map<String, Object> params ) { checkExecutionEngine(); logger.debug( "Running query:\n\n{}\n\nWith params:\n\n{}\n\n", cypher, params ); final String query = cypher.replaceAll( "(\\s)\\s+", "$1" ); final ExecutionResult result = params == null ? queryEngine.execute( query ) : queryEngine.execute( query, params ); // logger.info( "Execution plan:\n{}", result.executionPlanDescription() ); return result; }
GraphDatabaseService db = ...; // from version 2.2.x onwards db.execute("your cypher statement"); // before version 2.2.x ExecutionEngine engine = new ExecutionEngine(db) engine.execute("your cypher statement");
Transaction tx = graphDb.beginTx(); try{ ExecutionEngine engine = new ExecutionEngine(graphDb); ExecutionResult result = engine.execute("MATCH (n) RETURN n"); System.out.println(result.dumpToString()); tx.success(); } finally { tx.close(); }
static void writeResults(Appender appender, GraphDatabaseService dbService, List<String> queries, HashMap<String, Object> params, boolean includeHeader) throws IOException { for (String query : queries) { ExecutionResult rows = new ExecutionEngine(dbService).execute(query, params); List<String> columns = rows.columns(); if (includeHeader && queries.indexOf(query) == 0) { final String[] values = columns.toArray(new String[columns.size()]); appender.append(Stream.of(values)); } appendRow(appender, rows, columns); } }
public static void main( final String[] args ) { GraphDatabaseService graphDb = new GraphDatabaseFactory().newEmbeddedDatabase( DB_PATH ); ExecutionEngine e=new ExecutionEngine(graphDb); ExecutionResult rs=e.execute("match n return n limit 25"); System.out.println(rs.columns().size()); Iterator<Map<String, Object>> i= rs.iterator(); Iterator<Node> n_column = rs.columnAs( "n" ); while(n_column.hasNext()) { System.out.println(n_column.next().getProperty("name")); } }
private boolean contains(Atom atom, Transaction transaction) { String query = containsAtomIntoCypherQuery(atom, true); if (LOGGER.isDebugEnabled()) { LOGGER.debug(query); } ResourceIterator<Node> result = this.cypherEngine.execute(query).columnAs("atom"); boolean res = result.hasNext(); result.close(); return res; }
@Override public CloseableIterator<Atom> match(Atom atom) { String query = matchAtomIntoCypherQuery(atom); if (LOGGER.isDebugEnabled()) { LOGGER.debug(query); } ResourceIterator<Map<String, Object>> result = this.cypherEngine.execute(query).iterator(); return new Neo4jAtomIterator(this.getTransaction(), result); }
@Override @Deprecated public CloseableIterator<Term> termsIterator(Type type) throws AtomSetException { Map<String, Object> params = new TreeMap<String, Object>(); params.put("type", type.toString()); this.checkTransaction(); return new Neo4jTermIterator(this.getTransaction(), this.cypherEngine.execute( "match (term:TERM {type : { type }}) return term", params) .iterator()); }
@Override public void clear() { this.checkTransaction(); this.cypherEngine .execute("MATCH (n) OPTIONAL MATCH (n)-[r]-() DELETE n, r"); this.successTransaction(); this.reloadTransaction(); }
@Override public CloseableIterator<Atom> iterator() { this.checkTransaction(); return new Neo4jAtomIterator(this.getTransaction(), this.cypherEngine.execute( "match (atom:ATOM) return atom").iterator()); }
@Override public CloseableIterator<Predicate> predicatesIterator() throws AtomSetException { this.checkTransaction(); return new Neo4jPredicateIterator(this.getTransaction(), this.cypherEngine .execute("match (predicate:PREDICATE) return predicate") .iterator()); }
@Test public void create_node_using_create_unique_with_java_maps() throws Exception { Map<String, Object> props = new HashMap<String, Object>(); props.put( "name", "Andres" ); props.put( "position", "Developer" ); Map<String, Object> params = new HashMap<String, Object>(); params.put( "props", props ); String query = "START n=node(0) CREATE UNIQUE p = n-[:REL]->({props}) RETURN last(nodes(p)) AS X"; ExecutionResult result = engine.execute( query, params ); assertThat( count( result ), is( 1 ) ); }
public static Node getReferenceNode(GraphDatabaseService db, String name) { if (engine == null || db != dbRef) { engine = new ExecutionEngine(db); ReferenceNodes.dbRef = db; } ExecutionResult result = engine.execute("MERGE (ref:ReferenceNode {name:{name}}) RETURN ref", map("name", name)); return IteratorUtil.single(result.<Node>columnAs("ref")); } }
@Override public CloseableIterator<Term> termsIterator() throws AtomSetException { this.checkTransaction(); return new Neo4jTermIterator(this.getTransaction(), this.cypherEngine.execute( "match (term:TERM) return term").iterator()); }
@Test public void exampleWithParameterForMultipleNodeIds() throws Exception { // START SNIPPET: exampleWithParameterForMultipleNodeIds Map<String, Object> params = new HashMap<String, Object>(); params.put( "id", Arrays.asList( 0, 1, 2 ) ); String query = "START n=node({id}) RETURN n.name"; ExecutionResult result = engine.execute( query, params ); // END SNIPPET: exampleWithParameterForMultipleNodeIds assertEquals( asList( "Michaela", "Andreas", "Johan" ), this.<String>toList( result, "n.name" ) ); dumpToFile( "exampleWithParameterForMultipleNodeIds", query, params ); }
@Test public void exampleWithStringLiteralAsParameter() throws Exception { // START SNIPPET: exampleWithStringLiteralAsParameter Map<String, Object> params = new HashMap<String, Object>(); params.put( "name", "Johan" ); String query = "MATCH (n) WHERE n.name = {name} RETURN n"; ExecutionResult result = engine.execute( query, params ); // END SNIPPET: exampleWithStringLiteralAsParameter assertEquals( asList( johanNode ), this.<Node>toList( result, "n" ) ); dumpToFile( "exampleWithStringLiteralAsParameter", query, params ); }
@Test public void testColumnAreInTheRightOrder() throws Exception { createTenNodes(); String q = "start one=node(1), two=node(2), three=node(3), four=node(4), five=node(5), six=node(6), " + "seven=node(7), eight=node(8), nine=node(9), ten=node(10) " + "return one, two, three, four, five, six, seven, eight, nine, ten"; ExecutionResult result = engine.execute( q ); assertThat( result.dumpToString(), matchesPattern( "one.*two.*three.*four.*five.*six.*seven.*eight.*nine.*ten" ) ); }
@Test public void shouldBeAbleToEmitJavaIterables() throws Exception { makeFriends( michaelaNode, andreasNode ); makeFriends( michaelaNode, johanNode ); ExecutionEngine engine = new ExecutionEngine( db ); ExecutionResult result = engine.execute( "START n=node(0) MATCH n-->friend RETURN collect(friend)" ); Iterable<Node> friends = (Iterable<Node>) result.columnAs( "collect(friend)" ).next(); assertThat( friends, hasItems( andreasNode, johanNode ) ); assertThat( friends, instanceOf( Iterable.class ) ); }
@Test public void exampleQuery() throws Exception { // START SNIPPET: JavaQuery ExecutionEngine engine = new ExecutionEngine( db ); ExecutionResult result = engine.execute( "START n=node(0) WHERE 1=1 RETURN n" ); assertThat( result.columns(), hasItem( "n" ) ); Iterator<Node> n_column = result.columnAs( "n" ); assertThat( asIterable( n_column ), hasItem( db.getNodeById( 0 ) ) ); // END SNIPPET: JavaQuery }