@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));
}
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!");
}
public Concept getNextConceptToUpdate() {
synchronized (lock) {
IndexHits<Node> hits =
conceptsForUpdate.query(
new QueryContext(
NumericRangeQuery.newLongRange(
NamespaceConstants.DATE_UPDATED,
Long.MIN_VALUE,
Long.MAX_VALUE,
true,
true))
.sort(
new Sort(
new SortField(NamespaceConstants.DATE_UPDATED, SortField.LONG, false))));
if (hits.hasNext()) {
Node job = hits.next();
System.out.println(job.getId());
Concept concept = getByNode(job);
removeFromCU(concept);
return concept;
}
}
return null;
}
@Test
public void canUpdateShortStringInplace() throws Exception {
try {
long recordCount = dynamicRecordsInUse();
long propCount = propertyRecordsInUse();
Node node = graphdb.getGraphDatabaseService().createNode();
node.setProperty("key", "value");
newTx();
assertEquals(recordCount, dynamicRecordsInUse());
assertEquals(propCount + 1, propertyRecordsInUse());
assertEquals("value", node.getProperty("key"));
node.setProperty("key", "other");
commit();
assertEquals(recordCount, dynamicRecordsInUse());
assertEquals(propCount + 1, propertyRecordsInUse());
assertThat(
node, inTx(graphdb.getGraphDatabaseService(), hasProperty("key").withValue("other")));
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
/**
* Removes all nodes with non-valid resource classes from the graph.
*
* @param docGraph
* @param validResourceClasses
*/
private void preProcessGraph(DocGraph docGraph, Set<String> validResourceClasses) {
log.info(String.format("Preprocessing DocGraph[%d]", docGraph.getId()));
Node n;
int cnt = 0;
try (Transaction tx = graphDB.beginTx()) {
for (Long nodeId : docGraph.getNodes()) {
n = graphDB.getNodeById(nodeId);
// node's class is resource class and it's not in the valid set
if (n.hasProperty(Constants.NODE_SUPER_CLASS_KEY)
&& n.getProperty(Constants.NODE_SUPER_CLASS_KEY)
.equals(Constants.NODE_SUPER_CLASS_RESOURCE_VALUE)
&& !validResourceClasses.contains(getNodeClass(n))) {
try (Transaction innerTx = graphDB.beginTx()) {
log.info("Deleting " + n);
for (Relationship e : n.getRelationships()) {
e.delete();
}
n.delete();
innerTx.success();
cnt++;
}
}
}
tx.success();
}
log.info(
String.format("Preprocessing removed %d nodes from DocGraph[%d]", cnt, docGraph.getId()));
}
public void addCardInfoToNeo4j() {
DBCursor cursor = cardCollection.find();
DBObject sortObject = new BasicDBObject();
sortObject.put("name", 1);
// cursor = cursor.sort(sortObject);
cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
int count = 0;
while (cursor.hasNext()) {
DBObject cardObject = cursor.next();
String cardName = cardObject.get("name").toString().toUpperCase();
if (cardNodes.get(cardName) == null) {
Node newCardNode = graphDb.createNode();
newCardNode.setProperty("name", cardName);
for (String property : cardObject.keySet()) {
if (!property.equalsIgnoreCase("name")) {
newCardNode.setProperty(property, cardObject.get(property).toString());
}
}
cardNodes.put(cardName, newCardNode);
} else {
Node node = cardNodes.get(cardName);
for (String property : cardObject.keySet()) {
if (!property.equalsIgnoreCase("name")) {
node.setProperty(property, cardObject.get(property).toString());
}
}
}
count++;
System.out.println("Processed " + count + " card");
}
}
@Test
public void shouldOverwriteExistingProperties()
throws PropertyValueException, NodeNotFoundException {
long nodeId;
Transaction tx = database.getGraph().beginTx();
try {
Node node = database.getGraph().createNode();
node.setProperty("remove me", "trash");
nodeId = node.getId();
tx.success();
} finally {
tx.finish();
}
Map<String, Object> properties = new HashMap<String, Object>();
properties.put("foo", "bar");
properties.put("baz", 17);
actions.setAllNodeProperties(nodeId, properties);
tx = database.getGraph().beginTx();
try {
Node node = database.getGraph().getNodeById(nodeId);
assertHasProperties(node, properties);
assertNull(node.getProperty("remove me", null));
} finally {
tx.finish();
}
}
@Test
public void labelShouldBeRemovedAfterCommit() throws Exception {
// GIVEN
Transaction tx = db.beginTx();
Statement statement = statementContextProvider.instance();
Node node = db.createNode();
int labelId1 = statement.dataWriteOperations().labelGetOrCreateForName("labello1");
statement.dataWriteOperations().nodeAddLabel(node.getId(), labelId1);
statement.close();
tx.success();
tx.finish();
// WHEN
tx = db.beginTx();
statement = statementContextProvider.instance();
statement.dataWriteOperations().nodeRemoveLabel(node.getId(), labelId1);
statement.close();
tx.success();
tx.finish();
// THEN
tx = db.beginTx();
statement = statementContextProvider.instance();
PrimitiveIntIterator labels = statement.readOperations().nodeGetLabels(node.getId());
statement.close();
tx.success();
tx.finish();
assertThat(asSet(labels), equalTo(Collections.<Integer>emptySet()));
}
@Test
public void deletingNodeWithLabelsShouldHaveThoseLabelRemovalsReflectedInTransaction()
throws Exception {
// GIVEN
Transaction tx = db.beginTx();
Label label = label("labello");
Node node = db.createNode(label);
tx.success();
tx.finish();
tx = db.beginTx();
Statement statement = statementContextProvider.instance();
// WHEN
statement.dataWriteOperations().nodeDelete(node.getId());
// Then
int labelId = statement.readOperations().labelGetForName(label.name());
Set<Integer> labels = asSet(statement.readOperations().nodeGetLabels(node.getId()));
boolean labelIsSet = statement.readOperations().nodeHasLabel(node.getId(), labelId);
Set<Long> nodes = asSet(statement.readOperations().nodesGetForLabel(labelId));
statement.close();
tx.success();
tx.finish();
assertEquals(emptySetOf(Long.class), nodes);
assertEquals(emptySetOf(Integer.class), labels);
assertFalse("Label should not be set on node here", labelIsSet);
}
@Test
public void shouldNotBeAbleToCommitIfFailedTransactionContext() throws Exception {
Transaction tx = db.beginTx();
Statement statement = statementContextProvider.instance();
// WHEN
Node node = null;
int labelId = -1;
try {
node = db.createNode();
labelId = statement.dataWriteOperations().labelGetOrCreateForName("labello");
statement.dataWriteOperations().nodeAddLabel(node.getId(), labelId);
statement.close();
tx.failure();
tx.success();
tx.finish();
fail("Should have failed");
} catch (TransactionFailureException e) { // Expected
}
// THEN
tx = db.beginTx();
statement = statementContextProvider.instance();
try {
statement.readOperations().nodeHasLabel(node.getId(), labelId);
fail("should have thrown exception");
} catch (EntityNotFoundException e) {
// Yay!
}
tx.finish();
}
@Test
public void transactionStateShouldReflectRemovingLabelImmediately() throws Exception {
// GIVEN
Transaction tx = db.beginTx();
Statement statement = statementContextProvider.instance();
Node node = db.createNode();
int labelId1 = statement.dataWriteOperations().labelGetOrCreateForName("labello1");
int labelId2 = statement.dataWriteOperations().labelGetOrCreateForName("labello2");
statement.dataWriteOperations().nodeAddLabel(node.getId(), labelId1);
statement.dataWriteOperations().nodeAddLabel(node.getId(), labelId2);
statement.close();
tx.success();
tx.finish();
tx = db.beginTx();
statement = statementContextProvider.instance();
// WHEN
statement.dataWriteOperations().nodeRemoveLabel(node.getId(), labelId2);
// THEN
PrimitiveIntIterator labelsIterator = statement.readOperations().nodeGetLabels(node.getId());
Set<Integer> labels = asSet(labelsIterator);
assertFalse(statement.readOperations().nodeHasLabel(node.getId(), labelId2));
assertEquals(asSet(labelId1), labels);
statement.close();
tx.success();
tx.finish();
}
@SuppressWarnings("unchecked")
private void expand() {
Iterable<Relationship> expand = expander.expand(this, BranchState.NO_STATE);
for (Relationship rel : expand) {
lastMetadata.rels++;
Node node = rel.getOtherNode(lastNode);
Visit visit = visitData.get(node.getId());
if (visit != null && visit.visited) {
continue;
}
Visit lastVisit = visitData.get(lastNode.getId());
double tentativeGScore =
lastVisit.wayLength + lengthEvaluator.getCost(rel, Direction.OUTGOING);
double estimate = estimateEvaluator.getCost(node, end);
if (visit == null || !visit.next || tentativeGScore < visit.wayLength) {
if (visit == null) {
visit = new Visit(rel.getId(), tentativeGScore, estimate);
visitData.put(node.getId(), visit);
} else {
visit.update(rel.getId(), tentativeGScore, estimate);
}
addNext(node, estimate + tentativeGScore, visit);
}
}
}
@Test
public void testFindByIdFound() {
// Arrange
//
String id = "ABCDEF";
SubscriptionExpiry expiry = SubscriptionExpiry.NEVER;
Subscription expected = Subscription.builder().id(id).expiry(expiry).build();
when(mock_node.getProperty(eq(Subscription.PROP_ID))).thenReturn(expected.id());
when(mock_node.getProperty(eq(Subscription.PROP_EXPIRY)))
.thenReturn(expected.expiry().toString());
when(mock_db.beginTx()).thenReturn(mock_tx);
when(mock_db.findNode(eq(label), eq(Subscription.PROP_ID), eq(expected.id())))
.thenReturn(mock_node);
// Act
//
Subscription subs = s_dao.findById(id);
// Assert
//
assertNotNull(subs);
assertTrue(expected.equals(subs));
verify(mock_db, atLeastOnce()).beginTx();
verify(mock_db, times(1)).findNode(any(), any(), any());
verify(mock_tx, atLeastOnce()).success();
verify(mock_tx, times(1)).close();
}
public Node createNodeUsuario(Usuario usuario) {
Node lockNode;
try (Transaction tx = getManagerConnection().getGraphDb().beginTx()) {
lockNode = getManagerConnection().getGraphDb().createNode();
tx.success();
}
try (Transaction tx = getManagerConnection().beginTx()) {
Index<Node> usersIndex = getManagerConnection().getGraphDb().index().forNodes("users");
Node userNode = usersIndex.get("login", usuario.getLogin()).getSingle();
if (userNode != null) {
return userNode;
}
tx.acquireWriteLock(lockNode);
userNode = usersIndex.get("login", usuario.getLogin()).getSingle();
if (userNode == null) {
userNode = getManagerConnection().getGraphDb().createNode(DynamicLabel.label("User"));
usersIndex.add(userNode, "login", usuario.getLogin());
userNode.setProperty("login", usuario.getLogin());
userNode.setProperty("nome", usuario.getNome());
userNode.setProperty("senha", usuario.getSenha());
userNode.setProperty("type", usuario.getType().getName());
}
tx.success();
return userNode;
}
}
private void removeTupleOperation(
EntityKey entityKey,
Node node,
TupleOperation operation,
TupleContext tupleContext,
Set<String> processedAssociationRoles) {
if (!tupleContext.getTupleTypeContext().isPartOfAssociation(operation.getColumn())) {
if (isPartOfRegularEmbedded(entityKey.getColumnNames(), operation.getColumn())) {
// Embedded node
String[] split = split(operation.getColumn());
removePropertyForEmbedded(node, split, 0);
} else if (node.hasProperty(operation.getColumn())) {
node.removeProperty(operation.getColumn());
}
}
// if the column represents a to-one association, remove the relationship
else {
String associationRole = tupleContext.getTupleTypeContext().getRole(operation.getColumn());
if (!processedAssociationRoles.contains(associationRole)) {
Iterator<Relationship> relationships =
node.getRelationships(withName(associationRole)).iterator();
if (relationships.hasNext()) {
relationships.next().delete();
}
}
}
}
@Test
public void deletingNodeWithLabelsShouldHaveRemovalReflectedInLabelScans() throws Exception {
// GIVEN
Transaction tx = db.beginTx();
Label label = label("labello");
Node node = db.createNode(label);
tx.success();
tx.finish();
// AND GIVEN I DELETE IT
tx = db.beginTx();
node.delete();
tx.success();
tx.finish();
// WHEN
tx = db.beginTx();
Statement statement = statementContextProvider.instance();
int labelId = statement.readOperations().labelGetForName(label.name());
PrimitiveLongIterator nodes = statement.readOperations().nodesGetForLabel(labelId);
Set<Long> nodeSet = asSet(nodes);
tx.success();
tx.finish();
// THEN
assertThat(nodeSet, equalTo(Collections.<Long>emptySet()));
}
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));
}
}
/**
* While we transition ownership from the Beans API to the Kernel API for core database
* interactions, there will be a bit of a mess. Our first goal is an architecture like this:
*
* <p>Users / \ Beans API Cypher \ / Kernel API | Kernel Implementation
*
* <p>But our current intermediate architecture looks like this:
*
* <p>Users / \ Beans API <--- Cypher | \ / | Kernel API | | Kernel Implementation
*
* <p>Meaning Kernel API and Beans API both manipulate the underlying kernel, causing lots of
* corner cases. Most notably, those corner cases are related to Transactions, and the interplay
* between three transaction APIs: - The Beans API - The JTA Transaction Manager API - The Kernel
* TransactionContext API
*
* <p>In the long term, the goal is for JTA compliant stuff to live outside of the kernel, as an
* addon. The Kernel API will rule supreme over the land of transactions. We are a long way away
* from there, however, so as a first intermediary step, the JTA transaction manager rules
* supreme, and the Kernel API piggybacks on it.
*
* <p>This test shows us how to use both the Kernel API and the Beans API together in the same
* transaction, during the transition phase.
*/
@Test
public void mixingBeansApiWithKernelAPI() throws Exception {
// 1: Start your transactions through the Beans API
Transaction beansAPITx = db.beginTx();
// 2: Get a hold of a KernelAPI statement context for the *current* transaction this way:
Statement statement = statementContextProvider.instance();
// 3: Now you can interact through both the statement context and the kernel API to manipulate
// the
// same transaction.
Node node = db.createNode();
int labelId = statement.dataWriteOperations().labelGetOrCreateForName("labello");
statement.dataWriteOperations().nodeAddLabel(node.getId(), labelId);
// 4: Close the StatementContext
statement.close();
// 5: Commit through the beans API
beansAPITx.success();
beansAPITx.finish();
// NOTE: Transactions are still thread-bound right now, because we use JTA to "own"
// transactions,
// meaning if you use
// both the Kernel API to create transactions while a Beans API transaction is running in the
// same
// thread, the results are undefined.
// When the Kernel API implementation is done, the Kernel API transaction implementation is not
// meant
// to be bound to threads.
}
@Test
@Transactional
public void testCreateNodeTypeWithProperties() throws Exception {
Node person = neo4jTemplate.createNodeAs(Node.class, map("name", "name"));
assertNotNull("created node", person);
assertEquals("property created", "name", person.getProperty("name"));
}
private Object toJsonCompatible(Object value) {
if (value instanceof Node) {
final Node node = (Node) value;
final Map<String, Object> result = SubGraph.toMap(node);
result.put("_id", node.getId());
return result;
}
if (value instanceof Relationship) {
final Relationship relationship = (Relationship) value;
final Map<String, Object> result = SubGraph.toMap(relationship);
result.put("_id", relationship.getId());
result.put("_start", relationship.getStartNode().getId());
result.put("_end", relationship.getEndNode().getId());
result.put("_type", relationship.getType().name());
return result;
}
if (value instanceof Iterable) {
final List<Object> result = new ArrayList<Object>();
for (Object inner : (Iterable) value) {
result.add(toJsonCompatible(inner));
}
return result;
}
return value;
}
@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);
}
public static void aclerkTest(NeoTwDatabase neoTwDatabase) throws Exception {
final int aclerkId = 316751683;
System.out.println("Parsing...");
JSONObject aclerkJsonObject =
new JSONObject(
new String(Files.readAllBytes(Paths.get(SAMPLE_TWITTER_DIR + "aclerk.json"))));
System.out.println("Inserting...");
TwUser aclerkTwUser = new TwUser(aclerkJsonObject);
try (Transaction tx = neoTwDatabase.beginTx()) {
Node aclerkNode = neoTwDatabase.getOrCreateTwUserNode(aclerkTwUser);
tx.success();
}
System.out.println("Checking...");
try (Transaction tx = neoTwDatabase.beginTx()) {
Node aclerkNode = neoTwDatabase.getTwUserNodeById(aclerkTwUser.getId());
System.out.println(aclerkNode.getProperty("id"));
System.out.println(aclerkNode.getProperty("screenName"));
System.out.println(aclerkNode.getProperty("jsonObject"));
}
}
@Test
public void removeNodesWithARelation() {
int originalNodeCount = countNodesOf(graphDb);
int removedNodeCount = 0;
Transaction tx = graphDb.beginTx();
try {
Set<Node> toRemove = new HashSet<Node>();
for (Node node : graphDb.getAllNodes()) {
for (Relationship relationship : node.getRelationships(RelationType.ON)) {
toRemove.add(relationship.getStartNode());
toRemove.add(relationship.getEndNode());
relationship.delete();
}
}
for (Node node : toRemove) {
node.delete();
removedNodeCount++;
}
tx.success();
} finally {
tx.finish();
}
int finalNodeCount = countNodesOf(graphDb);
assertEquals(
Integer.valueOf(originalNodeCount), Integer.valueOf(finalNodeCount + removedNodeCount));
}
public static void completeTest(NeoTwDatabase neoTwDatabase) throws Exception {
// https://api.twitter.com/1.1/search/tweets.json?q=562b47a2e2704e07768b464c
System.out.println("Parsing...");
JSONObject completeJsonObject =
new JSONObject(
new String(Files.readAllBytes(Paths.get(SAMPLE_TWITTER_DIR + "complete.json"))));
System.out.println("Inserting...");
try (Transaction tx = neoTwDatabase.beginTx()) {
JSONArray statusesJsonArray = completeJsonObject.optJSONArray("statuses");
for (int i = 0; i < statusesJsonArray.length(); ++i) {
JSONObject jsonObject = statusesJsonArray.getJSONObject(i);
TwStatus twStatus = new TwStatus(jsonObject);
Node node = neoTwDatabase.getOrCreateTwStatusNode(twStatus);
}
tx.success();
}
System.out.println("Checking...");
try (Transaction tx = neoTwDatabase.beginTx()) {
JSONArray statusesJsonArray = completeJsonObject.optJSONArray("statuses");
for (int i = 0; i < statusesJsonArray.length(); ++i) {
JSONObject jsonObject = statusesJsonArray.getJSONObject(i);
TwStatus twStatus = new TwStatus(jsonObject);
Node node = neoTwDatabase.getTwStatusNodeById(twStatus.getId());
System.out.println(node.getProperty("jsonObject"));
}
}
}
private String getNodeSuperClass(Node n) {
if (n.hasProperty(Constants.NODE_SUPER_CLASS_KEY)) {
return (String) n.getProperty(Constants.NODE_SUPER_CLASS_KEY);
} else {
return "";
}
}
@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();
}
public void delete(ConstructionZoneNode zone) {
Node n = zone.getNode();
for (Relationship rel : n.getRelationships()) {
rel.delete();
}
n.delete();
}
@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();
}
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;
}
@Test
public void testStartStopAutoIndexing() 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();
AutoIndexer<Node> autoIndexer = graphDb.index().getNodeAutoIndexer();
assertTrue(autoIndexer.isEnabled());
autoIndexer.setEnabled(false);
assertFalse(autoIndexer.isEnabled());
newTransaction();
Node node1 = graphDb.createNode();
Node node2 = graphDb.createNode();
node1.setProperty("propName", "node");
newTransaction();
assertFalse(autoIndexer.getAutoIndex().get("nodeProp1", "node1").hasNext());
autoIndexer.setEnabled(true);
node2.setProperty("propName", "node");
newTransaction();
assertEquals(node2, autoIndexer.getAutoIndex().get("propName", "node").getSingle());
}