private void addMutantToDB( Individual original, Individual mutant, int generationNumber, Location location) { final GraphDatabaseService graphDB = GraphDB.graphDB(); IndexManager index = graphDB.index(); Index<Node> individualNodes = index.forNodes("individuals"); Index<Node> locationNodes = index.forNodes("locations"); Transaction tx = graphDB.beginTx(); Relationship mutantRelationship; Relationship node; Node individualNode; try { individualNode = graphDB.createNode(); individualNode.setProperty("fitness", mutant.getGlobalFitness()); individualNode.setProperty("id", mutant.uid.toString()); Node locationNode = locationNodes.get("locationID", location.getPosition()).next(); node = individualNode.createRelationshipTo(locationNode, RelTypes.LOCATEDIN); node.setProperty("generation", generationNumber); Node originalNode = individualNodes.get("id", original.uid.toString()).next(); mutantRelationship = individualNode.createRelationshipTo(originalNode, RelTypes.MUTANTOF); mutantRelationship.setProperty("generation", generationNumber); individualNodes.add(individualNode, "id", mutant.uid.toString()); tx.success(); } finally { tx.finish(); } }
@Test public void testRelationshipAddProperty() { Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship rel1 = node1.createRelationshipTo(node2, MyRelTypes.TEST); Relationship rel2 = node2.createRelationshipTo(node1, MyRelTypes.TEST); try { rel1.setProperty(null, null); fail("Null argument should result in exception."); } catch (IllegalArgumentException e) { } Integer int1 = new Integer(1); Integer int2 = new Integer(2); String string1 = new String("1"); String string2 = new String("2"); // add property rel1.setProperty(key1, int1); rel2.setProperty(key1, string1); rel1.setProperty(key2, string2); rel2.setProperty(key2, int2); assertTrue(rel1.hasProperty(key1)); assertTrue(rel2.hasProperty(key1)); assertTrue(rel1.hasProperty(key2)); assertTrue(rel2.hasProperty(key2)); assertTrue(!rel1.hasProperty(key3)); assertTrue(!rel2.hasProperty(key3)); assertEquals(int1, rel1.getProperty(key1)); assertEquals(string1, rel2.getProperty(key1)); assertEquals(string2, rel1.getProperty(key2)); assertEquals(int2, rel2.getProperty(key2)); getTransaction().failure(); }
@Test public void testRelationshipChangeProperty() { Integer int1 = new Integer(1); Integer int2 = new Integer(2); String string1 = new String("1"); String string2 = new String("2"); Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship rel1 = node1.createRelationshipTo(node2, MyRelTypes.TEST); Relationship rel2 = node2.createRelationshipTo(node1, MyRelTypes.TEST); rel1.setProperty(key1, int1); rel2.setProperty(key1, string1); rel1.setProperty(key2, string2); rel2.setProperty(key2, int2); try { rel1.setProperty(null, null); fail("Null argument should result in exception."); } catch (IllegalArgumentException e) { } catch (NotFoundException e) { fail("wrong exception"); } // test type change of exsisting property // cannot test this for now because of exceptions in PL rel2.setProperty(key1, int1); rel1.delete(); rel2.delete(); node2.delete(); node1.delete(); }
@Test public void testRelationshipAutoIndexFromAPISanity() { final String propNameToIndex = "test"; AutoIndexer<Relationship> autoIndexer = graphDb.index().getRelationshipAutoIndexer(); autoIndexer.startAutoIndexingProperty(propNameToIndex); autoIndexer.setEnabled(true); newTransaction(); Node node1 = graphDb.createNode(); Node node2 = graphDb.createNode(); Node node3 = graphDb.createNode(); Relationship rel12 = node1.createRelationshipTo(node2, DynamicRelationshipType.withName("DYNAMIC")); Relationship rel23 = node2.createRelationshipTo(node3, DynamicRelationshipType.withName("DYNAMIC")); rel12.setProperty(propNameToIndex, "rel12"); rel23.setProperty(propNameToIndex, "rel23"); newTransaction(); assertEquals(rel12, autoIndexer.getAutoIndex().get(propNameToIndex, "rel12").getSingle()); assertEquals(rel23, autoIndexer.getAutoIndex().get(propNameToIndex, "rel23").getSingle()); }
@Test public void testRelationshipCahinIterator() { Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship rels[] = new Relationship[100]; for (int i = 0; i < rels.length; i++) { if (i < 50) { rels[i] = node1.createRelationshipTo(node2, MyRelTypes.TEST); } else { rels[i] = node2.createRelationshipTo(node1, MyRelTypes.TEST); } } newTransaction(); getNodeManager().clearCache(); Iterable<Relationship> relIterable = node1.getRelationships(); for (Relationship rel : rels) { rel.delete(); } newTransaction(); for (Relationship rel : relIterable) { System.out.println(rel); } node1.delete(); node2.delete(); }
@Test public void makeSureLazyLoadingRelationshipsWorksEvenIfOtherIteratorAlsoLoadsInTheSameIteration() { int numEdges = 100; /* create 256 nodes */ GraphDatabaseService graphDB = getGraphDb(); Node[] nodes = new Node[256]; for (int num_nodes = 0; num_nodes < nodes.length; num_nodes += 1) { nodes[num_nodes] = graphDB.createNode(); } newTransaction(); /* create random outgoing relationships from node 5 */ Node hub = nodes[4]; int nextID = 7; RelationshipType outtie = withName("outtie"); RelationshipType innie = withName("innie"); for (int k = 0; k < numEdges; k++) { Node neighbor = nodes[nextID]; nextID += 7; nextID &= 255; if (nextID == 0) { nextID = 1; } hub.createRelationshipTo(neighbor, outtie); } newTransaction(); /* create random incoming relationships to node 5 */ for (int k = 0; k < numEdges; k += 1) { Node neighbor = nodes[nextID]; nextID += 7; nextID &= 255; if (nextID == 0) { nextID = 1; } neighbor.createRelationshipTo(hub, innie); } commit(); clearCache(); newTransaction(); hub = graphDB.getNodeById(hub.getId()); int count = 0; for (@SuppressWarnings("unused") Relationship r1 : hub.getRelationships()) { count += count(hub.getRelationships()); } assertEquals(40000, count); count = 0; for (@SuppressWarnings("unused") Relationship r1 : hub.getRelationships()) { count += count(hub.getRelationships()); } assertEquals(40000, count); commit(); }
@Test public void testRelationshipRemoveProperty() { Integer int1 = new Integer(1); Integer int2 = new Integer(2); String string1 = new String("1"); String string2 = new String("2"); Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship rel1 = node1.createRelationshipTo(node2, MyRelTypes.TEST); Relationship rel2 = node2.createRelationshipTo(node1, MyRelTypes.TEST); // verify that we can rely on PL to reomve non existing properties try { if (rel1.removeProperty(key1) != null) { fail("Remove of non existing property should return null"); } } catch (NotFoundException e) { } try { rel1.removeProperty(null); fail("Remove null property should throw exception."); } catch (IllegalArgumentException e) { } rel1.setProperty(key1, int1); rel2.setProperty(key1, string1); rel1.setProperty(key2, string2); rel2.setProperty(key2, int2); try { rel1.removeProperty(null); fail("Null argument should result in exception."); } catch (IllegalArgumentException e) { } // test remove property assertEquals(int1, rel1.removeProperty(key1)); assertEquals(string1, rel2.removeProperty(key1)); // test remove of non exsisting property try { if (rel2.removeProperty(key1) != null) { fail("Remove of non existing property should return null"); } } catch (NotFoundException e) { // have to set rollback only here getTransaction().failure(); } rel1.delete(); rel2.delete(); node1.delete(); node2.delete(); }
@Test public void testSimple() { Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship rel1 = node1.createRelationshipTo(node2, MyRelTypes.TEST); node1.createRelationshipTo(node2, MyRelTypes.TEST); rel1.delete(); newTransaction(); assertTrue(node1.getRelationships().iterator().hasNext()); assertTrue(node2.getRelationships().iterator().hasNext()); assertTrue(node1.getRelationships(MyRelTypes.TEST).iterator().hasNext()); assertTrue(node2.getRelationships(MyRelTypes.TEST).iterator().hasNext()); assertTrue(node1.getRelationships(MyRelTypes.TEST, Direction.OUTGOING).iterator().hasNext()); assertTrue(node2.getRelationships(MyRelTypes.TEST, Direction.INCOMING).iterator().hasNext()); }
@Test public void testRemoveRelationshipRemovesDocument() { AutoIndexer<Relationship> autoIndexer = graphDb.index().getRelationshipAutoIndexer(); autoIndexer.startAutoIndexingProperty("foo"); autoIndexer.setEnabled(true); newTransaction(); Node node1 = graphDb.createNode(); Node node2 = graphDb.createNode(); Relationship rel = node1.createRelationshipTo(node2, DynamicRelationshipType.withName("foo")); rel.setProperty("foo", "bar"); newTransaction(); assertThat( graphDb.index().forRelationships("relationship_auto_index").query("_id_:*").size(), equalTo(1)); newTransaction(); rel.delete(); newTransaction(); assertThat( graphDb.index().forRelationships("relationship_auto_index").query("_id_:*").size(), equalTo(0)); }
@Test public void testDefaultsAreSeparateForNodesAndRelationships() throws Exception { stopDb(); config = new HashMap<>(); config.put(GraphDatabaseSettings.node_keys_indexable.name(), "propName"); config.put(GraphDatabaseSettings.node_auto_indexing.name(), "true"); // Now only node properties named propName should be indexed. startDb(); newTransaction(); Node node1 = graphDb.createNode(); Node node2 = graphDb.createNode(); node1.setProperty("propName", "node1"); node2.setProperty("propName", "node2"); node2.setProperty("propName_", "node2"); Relationship rel = node1.createRelationshipTo(node2, DynamicRelationshipType.withName("DYNAMIC")); rel.setProperty("propName", "rel1"); newTransaction(); ReadableIndex<Node> autoIndex = graphDb.index().getNodeAutoIndexer().getAutoIndex(); assertEquals(node1, autoIndex.get("propName", "node1").getSingle()); assertEquals(node2, autoIndex.get("propName", "node2").getSingle()); assertFalse( graphDb .index() .getRelationshipAutoIndexer() .getAutoIndex() .get("propName", "rel1") .hasNext()); }
private void createSomeTransactions(GraphDatabaseService db) { Transaction tx = db.beginTx(); Node node1 = db.createNode(); Node node2 = db.createNode(); node1.createRelationshipTo(node2, DynamicRelationshipType.withName("relType1")); tx.success(); tx.finish(); tx = db.beginTx(); node1.delete(); tx.success(); try { // Will throw exception, causing the tx to be rolledback. tx.finish(); } catch (Exception nothingToSeeHereMoveAlong) { // InvalidRecordException coming, node1 has rels } /* * The damage has already been done. The following just makes sure * the corrupting tx is flushed to disk, since we will exit * uncleanly. */ tx = db.beginTx(); node1.setProperty("foo", "bar"); tx.success(); tx.finish(); }
@Override public void generate(String dbPath) { GraphDatabaseService graphDb = new EmbeddedGraphDatabase(dbPath); Index<Node> nodeIndex = graphDb .index() .forNodes("nodes", MapUtil.stringMap("provider", "lucene", "type", "fulltext")); Index<Relationship> relationshipIndex = graphDb .index() .forRelationships( "relationships", MapUtil.stringMap("provider", "lucene", "type", "fulltext")); Transaction tx = graphDb.beginTx(); try { Node n = graphDb.createNode(); Node n2 = graphDb.createNode(); Relationship rel = n.createRelationshipTo(n2, REL_TYPE); nodeIndex.add(n, "name", "alpha bravo"); nodeIndex.add(n2, "name", "charlie delta"); relationshipIndex.add(rel, "name", "echo foxtrot"); tx.success(); } finally { tx.finish(); } graphDb.shutdown(); }
@Test public void shouldBeAbleToGetPropertiesOnRelationship() throws Exception { long relationshipId; Map<String, Object> properties = new HashMap<String, Object>(); properties.put("foo", "bar"); properties.put("neo", "Thomas A. Anderson"); properties.put("number", 15L); Transaction tx = database.getGraph().beginTx(); try { Node startNode = database.getGraph().createNode(); Node endNode = database.getGraph().createNode(); Relationship relationship = startNode.createRelationshipTo(endNode, DynamicRelationshipType.withName("knows")); for (Map.Entry<String, Object> entry : properties.entrySet()) { relationship.setProperty(entry.getKey(), entry.getValue()); } relationshipId = relationship.getId(); tx.success(); } finally { tx.finish(); } Map<String, Object> readProperties = serialize(actions.getAllRelationshipProperties(relationshipId)); assertEquals(properties, readProperties); }
@Test public void testRelationshipChangeProperty2() { Integer int1 = new Integer(1); Integer int2 = new Integer(2); String string1 = new String("1"); String string2 = new String("2"); Boolean bool1 = new Boolean(true); Boolean bool2 = new Boolean(false); Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship rel1 = node1.createRelationshipTo(node2, MyRelTypes.TEST); rel1.setProperty(key1, int1); rel1.setProperty(key1, int2); assertEquals(int2, rel1.getProperty(key1)); rel1.removeProperty(key1); rel1.setProperty(key1, string1); rel1.setProperty(key1, string2); assertEquals(string2, rel1.getProperty(key1)); rel1.removeProperty(key1); rel1.setProperty(key1, bool1); rel1.setProperty(key1, bool2); assertEquals(bool2, rel1.getProperty(key1)); rel1.removeProperty(key1); rel1.delete(); node2.delete(); node1.delete(); }
@Test public void deleteRelsWithCommitInMiddle() throws Exception { Node node = getGraphDb().createNode(); Node otherNode = getGraphDb().createNode(); RelationshipType[] types = new RelationshipType[] {withName("r1"), withName("r2"), withName("r3"), withName("r4")}; int count = 30; // 30*4 > 100 (rel grabSize) for (int i = 0; i < types.length * count; i++) { node.createRelationshipTo(otherNode, types[i % types.length]); } newTransaction(); clearCache(); int delCount = 0; int loopCount = 0; while (delCount < count) { loopCount++; for (Relationship rel : node.getRelationships(types[1])) { rel.delete(); if (++delCount == count / 2) { newTransaction(); } } } assertEquals(1, loopCount); assertEquals(count, delCount); }
public RelationshipRepresentation createRelationship( long startNodeId, long endNodeId, String type, Map<String, Object> properties) throws StartNodeNotFoundException, EndNodeNotFoundException, PropertyValueException { Node start, end; try { start = node(startNodeId); } catch (NodeNotFoundException e) { throw new StartNodeNotFoundException(); } try { end = node(endNodeId); } catch (NodeNotFoundException e) { throw new EndNodeNotFoundException(); } final RelationshipRepresentation result; Transaction tx = graphDb.beginTx(); try { result = new RelationshipRepresentation( set( start.createRelationshipTo(end, DynamicRelationshipType.withName(type)), properties)); tx.success(); } finally { tx.finish(); } return result; }
@Before public void createTestingGraph() { Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship rel = node1.createRelationshipTo(node2, MyRelTypes.TEST); node1Id = (int) node1.getId(); node2Id = (int) node2.getId(); node1.setProperty(key1, int1); node1.setProperty(key2, string1); node2.setProperty(key1, int2); node2.setProperty(key2, string2); rel.setProperty(key1, int1); rel.setProperty(key2, string1); node1.setProperty(arrayKey, array); node2.setProperty(arrayKey, array); rel.setProperty(arrayKey, array); Transaction tx = getTransaction(); tx.success(); tx.finish(); NodeManager nodeManager = ((EmbeddedGraphDatabase) getGraphDb()).getConfig().getGraphDbModule().getNodeManager(); nodeManager.clearCache(); tx = getGraphDb().beginTx(); setTransaction(tx); }
@Test public void testRelationshipCreateAndDelete() { Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship relationship = node1.createRelationshipTo(node2, MyRelTypes.TEST); Relationship relArray1[] = getRelationshipArray(node1.getRelationships()); Relationship relArray2[] = getRelationshipArray(node2.getRelationships()); assertEquals(1, relArray1.length); assertEquals(relationship, relArray1[0]); assertEquals(1, relArray2.length); assertEquals(relationship, relArray2[0]); relArray1 = getRelationshipArray(node1.getRelationships(MyRelTypes.TEST)); assertEquals(1, relArray1.length); assertEquals(relationship, relArray1[0]); relArray2 = getRelationshipArray(node2.getRelationships(MyRelTypes.TEST)); assertEquals(1, relArray2.length); assertEquals(relationship, relArray2[0]); relArray1 = getRelationshipArray(node1.getRelationships(MyRelTypes.TEST, Direction.OUTGOING)); assertEquals(1, relArray1.length); relArray2 = getRelationshipArray(node2.getRelationships(MyRelTypes.TEST, Direction.INCOMING)); assertEquals(1, relArray2.length); relArray1 = getRelationshipArray(node1.getRelationships(MyRelTypes.TEST, Direction.INCOMING)); assertEquals(0, relArray1.length); relArray2 = getRelationshipArray(node2.getRelationships(MyRelTypes.TEST, Direction.OUTGOING)); assertEquals(0, relArray2.length); relationship.delete(); node2.delete(); node1.delete(); }
public void rn() throws IOException { List<RoadLink> links = loadToDatabase("/Users/duduba/gj.mif", "/Users/duduba/gj.mid", false); GraphDatabaseService graphDb = neo.getDb(); Index<Node> nodeIndex = neo.getNodeIndex(); for (RoadLink link : links) { Transaction tx = graphDb.beginTx(); try { Node fromNode = nodeIndex.get("id", link.fromNode).getSingle(); if (fromNode == null) { fromNode = graphDb.createNode(); fromNode.setProperty("id", link.fromNode); nodeIndex.add(fromNode, "id", link.fromNode); } Node toNode = nodeIndex.get("id", link.toNode).getSingle(); if (toNode == null) { toNode = graphDb.createNode(); toNode.setProperty("id", link.toNode); nodeIndex.add(toNode, "id", link.toNode); } Relationship r = fromNode.createRelationshipTo(toNode, Neo.RelTypes.TO); r.setProperty("no", link.no); r.setProperty("name", link.name); tx.success(); } finally { tx.finish(); } } logger.debug("haha, it's ok!"); }
@Test public void shouldLoadAllRelationships() throws Exception { // GIVEN GraphDatabaseAPI db = getGraphDbAPI(); Node node; try (Transaction tx = db.beginTx()) { node = db.createNode(); for (int i = 0; i < 112; i++) { node.createRelationshipTo(db.createNode(), MyRelTypes.TEST); db.createNode().createRelationshipTo(node, MyRelTypes.TEST); } tx.success(); } // WHEN db.getDependencyResolver().resolveDependency(NodeManager.class).clearCache(); int one, two; try (Transaction tx = db.beginTx()) { one = count(node.getRelationships(MyRelTypes.TEST, Direction.OUTGOING)); two = count(node.getRelationships(MyRelTypes.TEST, Direction.OUTGOING)); tx.success(); } // THEN assertEquals(two, one); }
@Test public void testRelMultiRemoveProperty() { Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship rel = node1.createRelationshipTo(node2, MyRelTypes.TEST); rel.setProperty("key0", "0"); rel.setProperty("key1", "1"); rel.setProperty("key2", "2"); rel.setProperty("key3", "3"); rel.setProperty("key4", "4"); newTransaction(); rel.removeProperty("key3"); rel.removeProperty("key2"); rel.removeProperty("key3"); newTransaction(); getNodeManager().clearCache(); assertEquals("0", rel.getProperty("key0")); assertEquals("1", rel.getProperty("key1")); assertEquals("4", rel.getProperty("key4")); assertTrue(!rel.hasProperty("key2")); assertTrue(!rel.hasProperty("key3")); rel.delete(); node1.delete(); node2.delete(); }
private void connect( final Integer fromFacebookId, final Integer toFacebookId, final ConnectionType connectionType) { final Transaction transaction = graphDb.beginTx(); try { final Node fromNode = this.getIndexedNode(fromFacebookId); final Node toNode = this.getIndexedNode(toFacebookId); if (fromNode == null || toNode == null) { if (logger.isWarnEnabled()) { logger.warn("Can't connect nodes {} <> {} because one or both does not exists."); } throw new ResourceNotFoundException("One or both sides of the connection does not exists."); } fromNode.createRelationshipTo(toNode, connectionType); if (logger.isInfoEnabled()) { logger.info( "{} is now Connected to {} with the {} relation.", fromNode.getProperty(Neo4JPersonRepository.PROPERTY_NAME), toNode.getProperty(Neo4JPersonRepository.PROPERTY_NAME), connectionType); } transaction.success(); } catch (final Exception e) { transaction.failure(); logger.error("Error connecting " + fromFacebookId + " to " + toFacebookId + ".", e); throw e; } finally { transaction.finish(); } }
private void createLink(final Lnk domainLink) throws ApplicationException { Transaction tx = graphDb.beginTx(); Node nodeA = null; Node nodeB = null; try { long keyValueA = Long.parseLong(domainLink.getaNode().trim()); long keyValueB = Long.parseLong(domainLink.getbNode().trim()); nodeA = nodeIndex.get(DomainConstants.PROP_NODE_ID, keyValueA).getSingle(); nodeB = nodeIndex.get(DomainConstants.PROP_NODE_ID, keyValueB).getSingle(); if (null == nodeA || null == nodeB) { throw new ApplicationException( String.format( "Link referenced %s A-Node with key %d, and the link referenced %s B-Node with key %d", nodeA, keyValueA, nodeB, keyValueB)); } log.info( String.format( "Link inserted from %s A-Node with key %d, to the link referenced %s B-Node with key %d", nodeA, keyValueA, nodeB, keyValueB)); nodeA.createRelationshipTo(nodeB, DomainConstants.RelTypes.DOMAIN_LINK); tx.success(); } catch (Exception e) { log.error(e.toString()); tx.failure(); throw new ApplicationException(e); } finally { tx.finish(); } }
private void putOneToOneAssociation( Tuple tuple, Node node, TupleOperation operation, TupleContext tupleContext, Set<String> processedAssociationRoles) { String associationRole = tupleContext.getTupleTypeContext().getRole(operation.getColumn()); if (!processedAssociationRoles.contains(associationRole)) { processedAssociationRoles.add(associationRole); EntityKey targetKey = getEntityKey( tuple, tupleContext .getTupleTypeContext() .getAssociatedEntityKeyMetadata(operation.getColumn())); // delete the previous relationship if there is one; for a to-one association, the // relationship won't have any // properties, so the type is uniquely identifying it Iterator<Relationship> relationships = node.getRelationships(withName(associationRole)).iterator(); if (relationships.hasNext()) { relationships.next().delete(); } // create a new relationship Node targetNode = entityQueries .get(targetKey.getMetadata()) .findEntity(dataBase, targetKey.getColumnValues()); node.createRelationshipTo(targetNode, withName(associationRole)); } }
@Test public void shouldBeAbleToImplementAnonymousGraphQuery() throws Exception { // given GraphDatabaseService db = Db.impermanentDb(); Transaction tx = db.beginTx(); Node firstNode = db.createNode(); Node secondNode = db.createNode(); firstNode.createRelationshipTo(secondNode, withName("CONNECTED_TO")); tx.success(); tx.finish(); GraphQuery query = new GraphQuery() { @Override public Iterable<Node> execute(Node startNode) { return startNode.traverse( Traverser.Order.DEPTH_FIRST, StopEvaluator.DEPTH_ONE, ReturnableEvaluator.ALL_BUT_START_NODE, withName("CONNECTED_TO"), Direction.OUTGOING); } }; // when Iterable<Node> result = query.execute(firstNode); // then Iterator<Node> iterator = result.iterator(); assertEquals(secondNode, iterator.next()); assertFalse(iterator.hasNext()); }
private long createDb() { GraphDatabaseService graphDb = new GraphDatabaseFactory().newEmbeddedDatabase(DB_PATH); long firstNodeId = -1; Transaction tx = graphDb.beginTx(); try { Node firstNode = graphDb.createNode(); firstNodeId = firstNode.getId(); firstNode.setProperty("message", "Hello, "); firstNode.setProperty( "someJson", "{\n \"is\" : \"vcard\",\n \"name\" : \"Jim Barritt\"\n}"); Node secondNode = graphDb.createNode(); secondNode.setProperty("message", "World!"); Relationship relationship = firstNode.createRelationshipTo(secondNode, KNOWS); relationship.setProperty("message", "brave Neo4j "); tx.success(); return firstNodeId; } finally { tx.finish(); graphDb.shutdown(); } }
private Node addNode(EmbeddedGraphDatabase graphDb) { Node referenceNode = graphDb.getReferenceNode(); Node node = graphDb.createNode(); node.setProperty("theId", node.getId()); referenceNode.createRelationshipTo(node, MyRels.TEST); return node; }
public static void main(String[] args) { GraphDatabaseFactory neodb = new GraphDatabaseFactory(); // Direccion de la Base de datos Neo4j GraphDatabaseService graphDb = neodb.newEmbeddedDatabase("C:\\Users\\Administrador\\Documents\\Neo4j\\default.graphdb"); try (Transaction tx = graphDb.beginTx()) { // Creacion de nodos con sus propiedades Node bobNode = graphDb.createNode(NodeType.Person); // Tipo del nodo Person bobNode.setProperty("Pid", 5001); bobNode.setProperty("Name", "Bob"); bobNode.setProperty("Age", 23); Node aliceNode = graphDb.createNode(NodeType.Person); aliceNode.setProperty("Pid", 5002); aliceNode.setProperty("Name", "Eve"); Node eveNode = graphDb.createNode(NodeType.Person); eveNode.setProperty("Name", "Eve"); Node itNode = graphDb.createNode(NodeType.Course); // TIpo del nodo Course itNode.setProperty("Id", 1); itNode.setProperty("Name", "IT Beginners"); itNode.setProperty("Location", "Room 153"); Node electronicNode = graphDb.createNode(NodeType.Course); electronicNode.setProperty("Name", "Electronics Advanced"); // Creacion de relaciones entre los nodos bobNode.createRelationshipTo(aliceNode, RelationType.Knows); // Tipo de relacion Knows Relationship bobRelIt = bobNode.createRelationshipTo( itNode, RelationType.BelongsTo); // Tipo de relacion BelongsTo bobRelIt.setProperty("Function", "Student"); Relationship bobRelElectronics = bobNode.createRelationshipTo(electronicNode, RelationType.BelongsTo); bobRelElectronics.setProperty("Function", "Supply Teacher"); Relationship aliceRelIt = aliceNode.createRelationshipTo(itNode, RelationType.BelongsTo); aliceRelIt.setProperty("Function", "Teacher"); tx.success(); // Proceso termino de forma exitosa } graphDb.shutdown(); // Cerrar base }
private void initIndexRoot() { Node layerNode = getRootNode(); if (!layerNode.hasRelationship(RTreeRelationshipTypes.RTREE_ROOT, Direction.OUTGOING)) { // index initialization Node root = database.createNode(); layerNode.createRelationshipTo(root, RTreeRelationshipTypes.RTREE_ROOT); } }
@Override public void rhs(final Collection<Neo4jSwitchSensorMatch> matches) { for (final Neo4jSwitchSensorMatch ssnm : matches) { final Node sw = ssnm.getSw(); final Node sensor = neoDriver.getGraphDb().createNode(labelSensor); sw.createRelationshipTo(sensor, relationshipTypeSensor); } }