@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 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(); }
@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 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(); }
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 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(); }
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 testAddPropertyThenDelete() { Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship rel = node1.createRelationshipTo(node2, MyRelTypes.TEST); rel.setProperty("test", "test"); newTransaction(); rel.setProperty("test2", "test2"); rel.delete(); node1.delete(); node2.delete(); newTransaction(); }
@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 shouldProvideTheCorrectRelationshipData() { GraphDatabaseService db = dbRule.getGraphDatabaseService(); // create a rel type so the next type id is non zero try (Transaction tx = db.beginTx()) { db.createNode() .createRelationshipTo(db.createNode(), DynamicRelationshipType.withName("TYPE")); } RelationshipType livesIn = DynamicRelationshipType.withName("LIVES_IN"); long relId; try (Transaction tx = db.beginTx()) { Node person = db.createNode(DynamicLabel.label("Person")); Node city = db.createNode(DynamicLabel.label("City")); Relationship rel = person.createRelationshipTo(city, livesIn); rel.setProperty("since", 2009); relId = rel.getId(); tx.success(); } final Set<String> changedRelationships = new HashSet<>(); db.registerTransactionEventHandler( new TransactionEventHandler.Adapter<Void>() { @Override public Void beforeCommit(TransactionData data) throws Exception { for (PropertyEntry<Relationship> entry : data.assignedRelationshipProperties()) { changedRelationships.add(entry.entity().getType().name()); } return null; } }); try (Transaction tx = db.beginTx()) { Relationship rel = db.getRelationshipById(relId); rel.setProperty("since", 2010); tx.success(); } assertEquals(1, changedRelationships.size()); assertTrue( livesIn + " not in " + changedRelationships.toString(), changedRelationships.contains(livesIn.name())); }
@Test public void testNodeChangeProperty() { Node node1 = getGraphDb().getNodeById(node1Id); Node node2 = getGraphDb().getNodeById(node2Id); Relationship rel = node1.getSingleRelationship(MyRelTypes.TEST, Direction.BOTH); // test change property node1.setProperty(key1, int2); node2.setProperty(key1, int1); rel.setProperty(key1, int2); int[] newIntArray = new int[] {3, 2, 1}; node1.setProperty(arrayKey, newIntArray); node2.setProperty(arrayKey, newIntArray); rel.setProperty(arrayKey, newIntArray); }
private void putAssociationOperation( Association association, AssociationKey associationKey, AssociationOperation action, AssociatedEntityKeyMetadata associatedEntityKeyMetadata) { Relationship relationship = associationQueries .get(associationKey.getMetadata()) .findRelationship(dataBase, associationKey, action.getKey()); if (relationship != null) { for (String relationshipProperty : associationKey.getMetadata().getRowKeyIndexColumnNames()) { relationship.setProperty(relationshipProperty, action.getValue().get(relationshipProperty)); } for (String column : associationKey .getMetadata() .getColumnsWithoutKeyColumns(action.getValue().getColumnNames())) { if (!isRowKeyColumn(associationKey.getMetadata(), column)) { relationship.getEndNode().setProperty(column, action.getValue().get(column)); } } GraphLogger.log("Updated relationship: %1$s", relationship); } else { relationship = createRelationship(associationKey, action.getValue(), associatedEntityKeyMetadata); GraphLogger.log("Created relationship: %1$s", relationship); } }
@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 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()); }
@Test public void testAddProperty() { String key3 = "key3"; Node node1 = getGraphDb().getNodeById(node1Id); Node node2 = getGraphDb().getNodeById(node2Id); Relationship rel = node1.getSingleRelationship(MyRelTypes.TEST, Direction.BOTH); // add new property node2.setProperty(key3, int1); rel.setProperty(key3, int2); assertTrue(node1.hasProperty(key1)); assertTrue(node2.hasProperty(key1)); assertTrue(node1.hasProperty(key2)); assertTrue(node2.hasProperty(key2)); assertTrue(node1.hasProperty(arrayKey)); assertTrue(node2.hasProperty(arrayKey)); assertTrue(rel.hasProperty(arrayKey)); assertTrue(!node1.hasProperty(key3)); assertTrue(node2.hasProperty(key3)); assertEquals(int1, node1.getProperty(key1)); assertEquals(int2, node2.getProperty(key1)); assertEquals(string1, node1.getProperty(key2)); assertEquals(string2, node2.getProperty(key2)); assertEquals(int1, rel.getProperty(key1)); assertEquals(string1, rel.getProperty(key2)); assertEquals(int2, rel.getProperty(key3)); }
@Test public void testChangeProperty() { Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship rel = node1.createRelationshipTo(node2, MyRelTypes.TEST); rel.setProperty("test", "test1"); newTransaction(); rel.setProperty("test", "test2"); rel.removeProperty("test"); rel.setProperty("test", "test3"); assertEquals("test3", rel.getProperty("test")); rel.removeProperty("test"); rel.setProperty("test", "test4"); newTransaction(); assertEquals("test4", rel.getProperty("test")); }
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(); } }
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 }
/** * The only properties added to a relationship are the columns representing the index of the * association. */ private void applyProperties( AssociationKey associationKey, Tuple associationRow, Relationship relationship) { String[] indexColumns = associationKey.getMetadata().getRowKeyIndexColumnNames(); for (int i = 0; i < indexColumns.length; i++) { String propertyName = indexColumns[i]; Object propertyValue = associationRow.get(propertyName); relationship.setProperty(propertyName, propertyValue); } }
@Test public void canAddShortStringToRelationship() throws Exception { long recordCount = dynamicRecordsInUse(); GraphDatabaseService db = graphdb.getGraphDatabaseService(); Relationship rel = db.createNode().createRelationshipTo(db.createNode(), withName("REL_TYPE")); rel.setProperty("type", "dimsedut"); commit(); assertEquals(recordCount, dynamicRecordsInUse()); assertThat(rel, inTx(db, hasProperty("type").withValue("dimsedut"))); }
private static Relationship arco(Node n1, Node n2) { Relationship relationship; try (Transaction tx = graphDb.beginTx()) { relationship = n1.createRelationshipTo(n2, RelTypes.STD); relationship.setProperty("type", "normal "); tx.success(); } System.out.println("arc created"); return relationship; }
@Test public void testAddCacheCleared() { Node nodeA = getGraphDb().createNode(); nodeA.setProperty("1", 1); Node nodeB = getGraphDb().createNode(); Relationship rel = nodeA.createRelationshipTo(nodeB, MyRelTypes.TEST); rel.setProperty("1", 1); getTransaction().success(); getTransaction().finish(); newTransaction(); NodeManager nodeManager = ((EmbeddedGraphDatabase) getGraphDb()).getConfig().getGraphDbModule().getNodeManager(); nodeManager.clearCache(); nodeA.createRelationshipTo(nodeB, MyRelTypes.TEST); int count = 0; for (Relationship relToB : nodeA.getRelationships(MyRelTypes.TEST)) { count++; } assertEquals(2, count); nodeA.setProperty("2", 2); assertEquals(1, nodeA.getProperty("1")); rel.setProperty("2", 2); assertEquals(1, rel.getProperty("1")); nodeManager.clearCache(); // trigger empty load getGraphDb().getNodeById(nodeA.getId()); getGraphDb().getRelationshipById(rel.getId()); // apply COW maps getTransaction().success(); getTransaction().finish(); newTransaction(); count = 0; for (Relationship relToB : nodeA.getRelationships(MyRelTypes.TEST)) { count++; } assertEquals(2, count); assertEquals(1, nodeA.getProperty("1")); assertEquals(1, rel.getProperty("1")); assertEquals(2, nodeA.getProperty("2")); assertEquals(2, rel.getProperty("2")); }
@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(); }
public void setRelationshipProperties(long relationshipId, Map<String, Object> properties) throws DatabaseBlockedException { Transaction tx = database.graph.beginTx(); try { Relationship relationship = database.graph.getRelationshipById(relationshipId); for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) { relationship.setProperty(propertyEntry.getKey(), propertyEntry.getValue()); } tx.success(); } finally { tx.finish(); } }
@Test public void deleteNodeRelTriggerPropertyRemoveEvents() { GraphDatabaseService db = dbRule.getGraphDatabaseService(); Node node1; Node node2; Relationship rel; try (Transaction tx = db.beginTx()) { node1 = db.createNode(); node2 = db.createNode(); rel = node1.createRelationshipTo(node2, RelTypes.TXEVENT); node1.setProperty("test1", "stringvalue"); node1.setProperty("test2", 1l); rel.setProperty("test1", "stringvalue"); rel.setProperty("test2", 1l); rel.setProperty("test3", new int[] {1, 2, 3}); tx.success(); } MyTxEventHandler handler = new MyTxEventHandler(); db.registerTransactionEventHandler(handler); try (Transaction tx = db.beginTx()) { GraphDatabaseAPI dbApi = dbRule.getGraphDatabaseAPI(); dbApi.getDependencyResolver().resolveDependency(NodeManager.class).clearCache(); rel.delete(); node1.delete(); node2.delete(); dbApi.getDependencyResolver().resolveDependency(NodeManager.class).clearCache(); tx.success(); } assertEquals("stringvalue", handler.nodeProps.get("test1")); assertEquals("stringvalue", handler.relProps.get("test1")); assertEquals(1l, handler.nodeProps.get("test2")); assertEquals(1l, handler.relProps.get("test2")); int[] intArray = (int[]) handler.relProps.get("test3"); assertEquals(3, intArray.length); assertEquals(1, intArray[0]); assertEquals(2, intArray[1]); assertEquals(3, intArray[2]); }
@Test public void testRelGetProperties() { Integer int1 = new Integer(1); Integer int2 = new Integer(2); String string = new String("3"); Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship rel1 = node1.createRelationshipTo(node2, MyRelTypes.TEST); try { rel1.getProperty(key1); fail("get non existing property din't throw exception"); } catch (NotFoundException e) { } try { rel1.getProperty(null); fail("get of null key din't throw exception"); } catch (IllegalArgumentException e) { } assertTrue(!rel1.hasProperty(key1)); assertTrue(!rel1.hasProperty(null)); rel1.setProperty(key1, int1); rel1.setProperty(key2, int2); rel1.setProperty(key3, string); assertTrue(rel1.hasProperty(key1)); assertTrue(rel1.hasProperty(key2)); assertTrue(rel1.hasProperty(key3)); try { rel1.removeProperty(key3); } catch (NotFoundException e) { fail("Remove of property failed."); } assertTrue(!rel1.hasProperty(key3)); assertTrue(!rel1.hasProperty(null)); rel1.delete(); node2.delete(); node1.delete(); }
@Test public void testDeletedRelationship() { Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship relationship = node1.createRelationshipTo(node2, MyRelTypes.TEST); relationship.delete(); try { relationship.setProperty("key1", new Integer(1)); fail("Adding property to deleted rel should throw exception."); } catch (Exception e) { // good } node1.delete(); node2.delete(); }
public void setRelationshipProperty(long relationshipId, String key, Object value) throws PropertyValueException, RelationshipNotFoundException { Relationship relationship = relationship(relationshipId); value = property(value); Transaction tx = graphDb.beginTx(); try { relationship.setProperty(key, value); tx.success(); } catch (IllegalArgumentException e) { throw new PropertyValueException(key, value); } finally { tx.finish(); } }
public Relationship createLink(Map<String, Node> nodes) { Node sourceNode = nodes.get(sourceNodeId); Node targetNode = nodes.get(targetNodeId); Relationship relationship = sourceNode.createRelationshipTo(targetNode, DynamicRelationshipType.withName(label)); Set<String> keys = props.keySet(); for (String key : keys) { relationship.setProperty(key, props.get(key)); } return relationship; }