/*
* It will remove a property from an embedded node if it exists.
* After deleting the property, if the node does not have any more properties and relationships (except for an incoming one),
* it will delete the embedded node as well.
*/
private void removePropertyForEmbedded(Node embeddedNode, String[] embeddedColumnSplit, int i) {
if (i == embeddedColumnSplit.length - 1) {
// Property
String property = embeddedColumnSplit[embeddedColumnSplit.length - 1];
if (embeddedNode.hasProperty(property)) {
embeddedNode.removeProperty(property);
}
} else {
Iterator<Relationship> iterator =
embeddedNode
.getRelationships(Direction.OUTGOING, withName(embeddedColumnSplit[i]))
.iterator();
if (iterator.hasNext()) {
removePropertyForEmbedded(iterator.next().getEndNode(), embeddedColumnSplit, i + 1);
}
}
if (!embeddedNode.getPropertyKeys().iterator().hasNext()) {
// Node without properties
Iterator<Relationship> iterator = embeddedNode.getRelationships().iterator();
if (iterator.hasNext()) {
Relationship relationship = iterator.next();
if (!iterator.hasNext()) {
// Node with only one relationship and no properties,
// we can remove it:
// It means we have removed all the properties from the embedded node
// and it is NOT an intermediate node like
// (entity) --> (embedded1) --> (embedded2)
relationship.delete();
embeddedNode.delete();
}
}
}
}
@Test
public void testIntType() {
int time = (int) System.currentTimeMillis();
Integer iValue = new Integer(time);
String key = "testing";
node1.setProperty(key, iValue);
newTransaction();
clearCache();
Integer propertyValue = null;
propertyValue = (Integer) node1.getProperty(key);
assertEquals(iValue, propertyValue);
iValue = new Integer((int) System.currentTimeMillis());
node1.setProperty(key, iValue);
newTransaction();
clearCache();
propertyValue = (Integer) node1.getProperty(key);
assertEquals(iValue, propertyValue);
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
node1.setProperty("other", 123L);
assertEquals(123L, node1.getProperty("other"));
newTransaction();
clearCache();
assertEquals(123L, node1.getProperty("other"));
}
@Test
public void testLongArray() {
long[] array1 = new long[] {1, 2, 3, 4, 5};
Long[] array2 = new Long[] {6l, 7l, 8l};
String key = "testlongarray";
node1.setProperty(key, array1);
newTransaction();
clearCache();
long[] propertyValue = null;
propertyValue = (long[]) node1.getProperty(key);
assertEquals(array1.length, propertyValue.length);
for (int i = 0; i < array1.length; i++) {
assertEquals(array1[i], propertyValue[i]);
}
node1.setProperty(key, array2);
newTransaction();
clearCache();
propertyValue = (long[]) node1.getProperty(key);
assertEquals(array2.length, propertyValue.length);
for (int i = 0; i < array2.length; i++) {
assertEquals(array2[i], new Long(propertyValue[i]));
}
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testChangesAreVisibleInTransaction() {
AutoIndexer<Node> autoIndexer = graphDb.index().getNodeAutoIndexer();
autoIndexer.startAutoIndexingProperty("nodeProp");
autoIndexer.setEnabled(true);
newTransaction();
Node node1 = graphDb.createNode();
node1.setProperty("nodeProp", "nodePropValue");
node1.setProperty("nodePropNonIndexable", "valueWhatever");
ReadableIndex<Node> nodeIndex = autoIndexer.getAutoIndex();
assertEquals(node1, nodeIndex.get("nodeProp", "nodePropValue").getSingle());
newTransaction();
Node node2 = graphDb.createNode();
node2.setProperty("nodeProp", "nodePropValue2");
assertEquals(node2, nodeIndex.get("nodeProp", "nodePropValue2").getSingle());
node2.setProperty("nodeProp", "nodePropValue3");
assertEquals(node2, nodeIndex.get("nodeProp", "nodePropValue3").getSingle());
node2.removeProperty("nodeProp");
assertFalse(nodeIndex.get("nodeProp", "nodePropValue2").hasNext());
assertFalse(nodeIndex.get("nodeProp", "nodePropValue3").hasNext());
newTransaction();
assertEquals(node1, nodeIndex.get("nodeProp", "nodePropValue").getSingle());
assertFalse(nodeIndex.get("nodeProp", "nodePropValue2").hasNext());
assertFalse(nodeIndex.get("nodeProp", "nodePropValue3").hasNext());
}
@Test
public void testFloatType() {
Float fValue = new Float(45.678f);
String key = "testfloat";
node1.setProperty(key, fValue);
newTransaction();
clearCache();
Float propertyValue = null;
propertyValue = (Float) node1.getProperty(key);
assertEquals(fValue, propertyValue);
fValue = new Float(5684.3243f);
node1.setProperty(key, fValue);
newTransaction();
clearCache();
propertyValue = (Float) node1.getProperty(key);
assertEquals(fValue, propertyValue);
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testLongType() {
long time = System.currentTimeMillis();
Long lValue = new Long(time);
String key = "testlong";
node1.setProperty(key, lValue);
newTransaction();
clearCache();
Long propertyValue = null;
propertyValue = (Long) node1.getProperty(key);
assertEquals(lValue, propertyValue);
lValue = new Long(System.currentTimeMillis());
node1.setProperty(key, lValue);
newTransaction();
clearCache();
propertyValue = (Long) node1.getProperty(key);
assertEquals(lValue, propertyValue);
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
node1.setProperty("other", 123L);
assertEquals(123L, node1.getProperty("other"));
newTransaction();
clearCache();
assertEquals(123L, node1.getProperty("other"));
}
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 testCharArray() {
char[] array1 = new char[] {'1', '2', '3', '4', '5'};
Character[] array2 = new Character[] {'6', '7', '8'};
String key = "testchararray";
node1.setProperty(key, array1);
newTransaction();
clearCache();
char[] propertyValue = null;
propertyValue = (char[]) node1.getProperty(key);
assertEquals(array1.length, propertyValue.length);
for (int i = 0; i < array1.length; i++) {
assertEquals(array1[i], propertyValue[i]);
}
node1.setProperty(key, array2);
newTransaction();
clearCache();
propertyValue = (char[]) node1.getProperty(key);
assertEquals(array2.length, propertyValue.length);
for (int i = 0; i < array2.length; i++) {
assertEquals(array2[i], new Character(propertyValue[i]));
}
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testByteType() {
byte b = (byte) 177;
Byte bValue = new Byte(b);
String key = "testbyte";
node1.setProperty(key, bValue);
newTransaction();
clearCache();
Byte propertyValue = null;
propertyValue = (Byte) node1.getProperty(key);
assertEquals(bValue, propertyValue);
bValue = new Byte((byte) 200);
node1.setProperty(key, bValue);
newTransaction();
clearCache();
propertyValue = (Byte) node1.getProperty(key);
assertEquals(bValue, propertyValue);
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testBooleanType() {
boolean value = true;
Boolean bValue = new Boolean(value);
String key = "testbool";
node1.setProperty(key, bValue);
newTransaction();
clearCache();
Boolean propertyValue = null;
propertyValue = (Boolean) node1.getProperty(key);
assertEquals(bValue, propertyValue);
bValue = new Boolean(false);
node1.setProperty(key, bValue);
newTransaction();
clearCache();
propertyValue = (Boolean) node1.getProperty(key);
assertEquals(bValue, propertyValue);
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testDoubleArray() {
double[] array1 = new double[] {1.0, 2.0, 3.0, 4.0, 5.0};
Double[] array2 = new Double[] {6.0, 7.0, 8.0};
String key = "testdoublearray";
node1.setProperty(key, array1);
newTransaction();
clearCache();
double propertyValue[] = null;
propertyValue = (double[]) node1.getProperty(key);
assertEquals(array1.length, propertyValue.length);
for (int i = 0; i < array1.length; i++) {
assertEquals(array1[i], propertyValue[i], 0.0);
}
node1.setProperty(key, array2);
newTransaction();
clearCache();
propertyValue = (double[]) node1.getProperty(key);
assertEquals(array2.length, propertyValue.length);
for (int i = 0; i < array2.length; i++) {
assertEquals(array2[i], new Double(propertyValue[i]));
}
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testFloatArray() {
float[] array1 = new float[] {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
Float[] array2 = new Float[] {6.0f, 7.0f, 8.0f};
String key = "testfloatarray";
node1.setProperty(key, array1);
newTransaction();
clearCache();
float propertyValue[] = null;
propertyValue = (float[]) node1.getProperty(key);
assertEquals(array1.length, propertyValue.length);
for (int i = 0; i < array1.length; i++) {
assertEquals(array1[i], propertyValue[i], 0.0);
}
node1.setProperty(key, array2);
newTransaction();
clearCache();
propertyValue = (float[]) node1.getProperty(key);
assertEquals(array2.length, propertyValue.length);
for (int i = 0; i < array2.length; i++) {
assertEquals(array2[i], new Float(propertyValue[i]));
}
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testStringArray() {
String[] array1 = new String[] {"a", "b", "c", "d", "e"};
String[] array2 = new String[] {"ff", "gg", "hh"};
String key = "teststringarray";
node1.setProperty(key, array1);
newTransaction();
clearCache();
String propertyValue[] = null;
propertyValue = (String[]) node1.getProperty(key);
assertEquals(array1.length, propertyValue.length);
for (int i = 0; i < array1.length; i++) {
assertEquals(array1[i], propertyValue[i]);
}
node1.setProperty(key, array2);
newTransaction();
clearCache();
propertyValue = (String[]) node1.getProperty(key);
assertEquals(array2.length, propertyValue.length);
for (int i = 0; i < array2.length; i++) {
assertEquals(array2[i], propertyValue[i]);
}
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testBooleanArray() {
boolean[] array1 = new boolean[] {true, false, true, false, true};
Boolean[] array2 = new Boolean[] {false, true, false};
String key = "testboolarray";
node1.setProperty(key, array1);
newTransaction();
clearCache();
boolean propertyValue[] = null;
propertyValue = (boolean[]) node1.getProperty(key);
assertEquals(array1.length, propertyValue.length);
for (int i = 0; i < array1.length; i++) {
assertEquals(array1[i], propertyValue[i]);
}
node1.setProperty(key, array2);
newTransaction();
clearCache();
propertyValue = (boolean[]) node1.getProperty(key);
assertEquals(array2.length, propertyValue.length);
for (int i = 0; i < array2.length; i++) {
assertEquals(array2[i], new Boolean(propertyValue[i]));
}
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testCharType() {
char c = 'c';
Character cValue = new Character(c);
String key = "testchar";
node1.setProperty(key, cValue);
newTransaction();
clearCache();
Character propertyValue = null;
propertyValue = (Character) node1.getProperty(key);
assertEquals(cValue, propertyValue);
cValue = new Character('d');
node1.setProperty(key, cValue);
newTransaction();
clearCache();
propertyValue = (Character) node1.getProperty(key);
assertEquals(cValue, propertyValue);
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testIntArray() {
int[] array1 = new int[] {1, 2, 3, 4, 5};
Integer[] array2 = new Integer[] {6, 7, 8};
String key = "testintarray";
node1.setProperty(key, array1);
newTransaction();
clearCache();
int propertyValue[] = null;
propertyValue = (int[]) node1.getProperty(key);
assertEquals(array1.length, propertyValue.length);
for (int i = 0; i < array1.length; i++) {
assertEquals(array1[i], propertyValue[i]);
}
node1.setProperty(key, array2);
newTransaction();
clearCache();
propertyValue = (int[]) node1.getProperty(key);
assertEquals(array2.length, propertyValue.length);
for (int i = 0; i < array2.length; i++) {
assertEquals(array2[i], new Integer(propertyValue[i]));
}
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testShortType() {
short value = 453;
Short sValue = new Short(value);
String key = "testshort";
node1.setProperty(key, sValue);
newTransaction();
clearCache();
Short propertyValue = null;
propertyValue = (Short) node1.getProperty(key);
assertEquals(sValue, propertyValue);
sValue = new Short((short) 5335);
node1.setProperty(key, sValue);
newTransaction();
clearCache();
propertyValue = (Short) node1.getProperty(key);
assertEquals(sValue, propertyValue);
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testRemoveUnloadedHeavyProperty() {
/*
* Checks a bug where removing non-cached heavy properties
* would cause NPE in auto indexer.
*/
graphDb.index().getNodeAutoIndexer().setEnabled(true);
graphDb.index().getNodeAutoIndexer().startAutoIndexingProperty("nodeProp");
newTransaction();
Node node1 = graphDb.createNode();
// Large array, needed for making sure this is a heavy property
node1.setProperty("nodeProp", new int[] {-1, 2, 3, 4, 5, 6, 1, 1, 1, 1});
newTransaction();
// clear the caches
NeoStoreXaDataSource dataSource =
graphDb.getDependencyResolver().resolveDependency(NeoStoreXaDataSource.class);
dataSource.getNodeCache().clear();
dataSource.getRelationshipCache().clear();
node1.removeProperty("nodeProp");
newTransaction();
assertFalse(node1.hasProperty("nodeProp"));
}
@Test
public void testByteArray() {
byte[] array1 = new byte[] {1, 2, 3, 4, 5};
Byte[] array2 = new Byte[] {6, 7, 8};
String key = "testbytearray";
node1.setProperty(key, array1);
newTransaction();
clearCache();
byte[] propertyValue = null;
propertyValue = (byte[]) node1.getProperty(key);
assertEquals(array1.length, propertyValue.length);
for (int i = 0; i < array1.length; i++) {
assertEquals(array1[i], propertyValue[i]);
}
node1.setProperty(key, array2);
newTransaction();
clearCache();
propertyValue = (byte[]) node1.getProperty(key);
assertEquals(array2.length, propertyValue.length);
for (int i = 0; i < array2.length; i++) {
assertEquals(array2[i], new Byte(propertyValue[i]));
}
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testNodeMultiRemoveProperty() {
Node node = getGraphDb().createNode();
node.setProperty("key0", "0");
node.setProperty("key1", "1");
node.setProperty("key2", "2");
node.setProperty("key3", "3");
node.setProperty("key4", "4");
newTransaction();
node.removeProperty("key3");
node.removeProperty("key2");
node.removeProperty("key3");
newTransaction();
getNodeManager().clearCache();
assertEquals("0", node.getProperty("key0"));
assertEquals("1", node.getProperty("key1"));
assertEquals("4", node.getProperty("key4"));
assertTrue(!node.hasProperty("key2"));
assertTrue(!node.hasProperty("key3"));
node.delete();
}
public void removeNodeProperty(long nodeId, String key)
throws NodeNotFoundException, NoSuchPropertyException {
Node node = node(nodeId);
Transaction tx = graphDb.beginTx();
try {
if (node.removeProperty(key) == null) {
throw new NoSuchPropertyException(node, key);
}
tx.success();
} finally {
tx.finish();
}
}
@Test
public void shouldAllowRemoveAndAddConflictingDataInOneTransaction_RemoveProperty()
throws Exception {
// given
Node node = constrainedNode("Label1", "key1", "value1");
newTransaction();
// when
node.removeProperty("key1");
db.createNode(label("Label1")).setProperty("key1", "value1");
commit();
}
@Test
public void canRemoveShortStringProperty() throws Exception {
long recordCount = dynamicRecordsInUse();
long propCount = propertyRecordsInUse();
GraphDatabaseService db = graphdb.getGraphDatabaseService();
Node node = db.createNode();
node.setProperty("key", "value");
newTx();
assertEquals(recordCount, dynamicRecordsInUse());
assertEquals(propCount + 1, propertyRecordsInUse());
assertEquals("value", node.getProperty("key"));
node.removeProperty("key");
commit();
assertEquals(recordCount, dynamicRecordsInUse());
assertEquals(propCount, propertyRecordsInUse());
assertThat(node, inTx(db, not(hasProperty("key"))));
}
@Test
public void testDoubleType() {
Double dValue = new Double(45.678d);
String key = "testdouble";
node1.setProperty(key, dValue);
newTransaction();
clearCache();
Double propertyValue = null;
propertyValue = (Double) node1.getProperty(key);
assertEquals(dValue, propertyValue);
dValue = new Double(56784.3243d);
node1.setProperty(key, dValue);
newTransaction();
clearCache();
propertyValue = (Double) node1.getProperty(key);
assertEquals(dValue, propertyValue);
node1.removeProperty(key);
newTransaction();
clearCache();
assertTrue(!node1.hasProperty(key));
}
@Test
public void testNodeRemoveProperty() {
Node node1 = getGraphDb().getNodeById(node1Id);
Node node2 = getGraphDb().getNodeById(node2Id);
Relationship rel = node1.getSingleRelationship(MyRelTypes.TEST, Direction.BOTH);
// test remove property
assertEquals(1, node1.removeProperty(key1));
assertEquals(2, node2.removeProperty(key1));
assertEquals(1, rel.removeProperty(key1));
assertEquals(string1, node1.removeProperty(key2));
assertEquals(string2, node2.removeProperty(key2));
assertEquals(string1, rel.removeProperty(key2));
assertTrue(node1.removeProperty(arrayKey) != null);
assertTrue(node2.removeProperty(arrayKey) != null);
assertTrue(rel.removeProperty(arrayKey) != null);
}
@Test
public void shouldGetCorrectTransactionDataUponCommit() {
// Create new data, nothing modified, just added/created
ExpectedTransactionData expectedData = new ExpectedTransactionData();
VerifyingTransactionEventHandler handler = new VerifyingTransactionEventHandler(expectedData);
GraphDatabaseService db = dbRule.getGraphDatabaseService();
db.registerTransactionEventHandler(handler);
Node node1 = null, node2, node3 = null;
Relationship rel1 = null, rel2 = null;
try {
try (Transaction tx = db.beginTx()) {
node1 = db.createNode();
expectedData.expectedCreatedNodes.add(node1);
node2 = db.createNode();
expectedData.expectedCreatedNodes.add(node2);
rel1 = node1.createRelationshipTo(node2, RelTypes.TXEVENT);
expectedData.expectedCreatedRelationships.add(rel1);
node1.setProperty("name", "Mattias");
expectedData.assignedProperty(node1, "name", "Mattias", null);
node1.setProperty("last name", "Persson");
expectedData.assignedProperty(node1, "last name", "Persson", null);
node1.setProperty("counter", 10);
expectedData.assignedProperty(node1, "counter", 10, null);
rel1.setProperty("description", "A description");
expectedData.assignedProperty(rel1, "description", "A description", null);
rel1.setProperty("number", 4.5D);
expectedData.assignedProperty(rel1, "number", 4.5D, null);
node3 = db.createNode();
expectedData.expectedCreatedNodes.add(node3);
rel2 = node3.createRelationshipTo(node2, RelTypes.TXEVENT);
expectedData.expectedCreatedRelationships.add(rel2);
node3.setProperty("name", "Node 3");
expectedData.assignedProperty(node3, "name", "Node 3", null);
tx.success();
}
assertTrue("Should have been invoked", handler.hasBeenCalled());
if (handler.failure() != null) {
throw new RuntimeException(handler.failure());
}
} finally {
db.unregisterTransactionEventHandler(handler);
}
// Use the above data and modify it, change properties, delete stuff
expectedData = new ExpectedTransactionData();
handler = new VerifyingTransactionEventHandler(expectedData);
db.registerTransactionEventHandler(handler);
try {
try (Transaction tx = db.beginTx()) {
Node newNode = db.createNode();
expectedData.expectedCreatedNodes.add(newNode);
Node tempNode = db.createNode();
Relationship tempRel = tempNode.createRelationshipTo(node1, RelTypes.TXEVENT);
tempNode.setProperty("something", "Some value");
tempRel.setProperty("someproperty", 101010);
tempNode.removeProperty("nothing");
node3.setProperty("test", "hello");
node3.setProperty("name", "No name");
node3.delete();
expectedData.expectedDeletedNodes.add(node3);
expectedData.removedProperty(node3, "name", null, "Node 3");
node1.setProperty("new name", "A name");
node1.setProperty("new name", "A better name");
expectedData.assignedProperty(node1, "new name", "A better name", null);
node1.setProperty("name", "Nothing");
node1.setProperty("name", "Mattias Persson");
expectedData.assignedProperty(node1, "name", "Mattias Persson", "Mattias");
node1.removeProperty("counter");
expectedData.removedProperty(node1, "counter", null, 10);
node1.removeProperty("last name");
node1.setProperty("last name", "Hi");
expectedData.assignedProperty(node1, "last name", "Hi", "Persson");
rel2.delete();
expectedData.expectedDeletedRelationships.add(rel2);
rel1.removeProperty("number");
expectedData.removedProperty(rel1, "number", null, 4.5D);
rel1.setProperty("description", "Ignored");
rel1.setProperty("description", "New");
expectedData.assignedProperty(rel1, "description", "New", "A description");
tempRel.delete();
tempNode.delete();
tx.success();
}
assertTrue("Should have been invoked", handler.hasBeenCalled());
if (handler.failure() != null) {
throw new RuntimeException(handler.failure());
}
} finally {
db.unregisterTransactionEventHandler(handler);
}
}
@BreakpointTrigger
void removeProperty(Node node, String key) {
node.removeProperty(key);
}
private Node quadraticSplit(Node indexNode, RelationshipType relationshipType) {
List<Node> entries = new ArrayList<Node>();
Iterable<Relationship> relationships =
indexNode.getRelationships(relationshipType, Direction.OUTGOING);
for (Relationship relationship : relationships) {
entries.add(relationship.getEndNode());
relationship.delete();
}
// pick two seed entries such that the dead space is maximal
Node seed1 = null;
Node seed2 = null;
double worst = Double.NEGATIVE_INFINITY;
for (int i = 0; i < entries.size(); ++i) {
Node e = entries.get(i);
Envelope eEnvelope = getChildNodeEnvelope(e, relationshipType);
for (int j = i + 1; j < entries.size(); ++j) {
Node e1 = entries.get(j);
Envelope e1Envelope = getChildNodeEnvelope(e1, relationshipType);
double deadSpace =
getArea(createEnvelope(eEnvelope, e1Envelope))
- getArea(eEnvelope)
- getArea(e1Envelope);
if (deadSpace > worst) {
worst = deadSpace;
seed1 = e;
seed2 = e1;
}
}
}
List<Node> group1 = new ArrayList<Node>();
group1.add(seed1);
Envelope group1envelope = getChildNodeEnvelope(seed1, relationshipType);
List<Node> group2 = new ArrayList<Node>();
group2.add(seed2);
Envelope group2envelope = getChildNodeEnvelope(seed2, relationshipType);
entries.remove(seed1);
entries.remove(seed2);
while (entries.size() > 0) {
// compute the cost of inserting each entry
List<Node> bestGroup = null;
Envelope bestGroupEnvelope = null;
Node bestEntry = null;
double expansionMin = Double.POSITIVE_INFINITY;
for (Node e : entries) {
Envelope nodeEnvelope = getChildNodeEnvelope(e, relationshipType);
double expansion1 =
getArea(createEnvelope(nodeEnvelope, group1envelope)) - getArea(group1envelope);
double expansion2 =
getArea(createEnvelope(nodeEnvelope, group2envelope)) - getArea(group2envelope);
if (expansion1 < expansion2 && expansion1 < expansionMin) {
bestGroup = group1;
bestGroupEnvelope = group1envelope;
bestEntry = e;
expansionMin = expansion1;
} else if (expansion2 < expansion1 && expansion2 < expansionMin) {
bestGroup = group2;
bestGroupEnvelope = group2envelope;
bestEntry = e;
expansionMin = expansion2;
} else if (expansion1 == expansion2 && expansion1 < expansionMin) {
// in case of equality choose the group with the smallest area
if (getArea(group1envelope) < getArea(group2envelope)) {
bestGroup = group1;
bestGroupEnvelope = group1envelope;
} else {
bestGroup = group2;
bestGroupEnvelope = group2envelope;
}
bestEntry = e;
expansionMin = expansion1;
}
}
// insert the best candidate entry in the best group
bestGroup.add(bestEntry);
bestGroupEnvelope.expandToInclude(getChildNodeEnvelope(bestEntry, relationshipType));
entries.remove(bestEntry);
}
// reset bounding box and add new children
indexNode.removeProperty(INDEX_PROP_BBOX);
for (Node node : group1) {
addChild(indexNode, relationshipType, node);
}
// create new node from split
Node newIndexNode = database.createNode();
for (Node node : group2) {
addChild(newIndexNode, relationshipType, node);
}
return newIndexNode;
}
@Override
protected void doSomething() throws Throwable {
Pair<Integer, Node> pair = getNode(random, false);
Node node = pair.other();
node.removeProperty(randomPropertyKey(random));
}
@Test
public void testMutations() throws Exception {
graphDb.index().getNodeAutoIndexer().startAutoIndexingProperty("nodeProp1");
graphDb.index().getNodeAutoIndexer().startAutoIndexingProperty("nodeProp2");
graphDb.index().getNodeAutoIndexer().setEnabled(true);
Transaction tx = graphDb.beginTx();
Node node1 = null, node2 = null, node3 = null, node4 = null;
try {
// Create the primitives
node1 = graphDb.createNode();
node2 = graphDb.createNode();
node3 = graphDb.createNode();
node4 = graphDb.createNode();
// Add indexable and non-indexable properties
node1.setProperty("nodeProp1", "nodeProp1Value");
node2.setProperty("nodeProp2", "nodeProp2Value");
node3.setProperty("nodeProp1", "nodeProp3Value");
node4.setProperty("nodeProp2", "nodeProp4Value");
// Make things persistent
tx.success();
} finally {
tx.finish();
}
/*
* Here both nodes are indexed. To demonstrate removal, we stop
* auto-indexing nodeProp1.
*/
AutoIndexer<Node> nodeAutoIndexer = graphDb.index().getNodeAutoIndexer();
nodeAutoIndexer.stopAutoIndexingProperty("nodeProp1");
tx = graphDb.beginTx();
try {
/*
* nodeProp1 is no longer auto indexed. It will be
* removed regardless. Note that node3 will remain.
*/
node1.setProperty("nodeProp1", "nodeProp1Value2");
/*
* node2 will be auto updated
*/
node2.setProperty("nodeProp2", "nodeProp2Value2");
/*
* remove node4 property nodeProp2 from index.
*/
node4.removeProperty("nodeProp2");
// Make things persistent
tx.success();
} catch (Exception e) {
tx.failure();
} finally {
tx.finish();
}
Transaction transaction = graphDb.beginTx();
// Verify
ReadableIndex<Node> nodeAutoIndex = nodeAutoIndexer.getAutoIndex();
// node1 is completely gone
assertFalse(nodeAutoIndex.get("nodeProp1", "nodeProp1Value").hasNext());
assertFalse(nodeAutoIndex.get("nodeProp1", "nodeProp1Value2").hasNext());
// node2 is updated
assertFalse(nodeAutoIndex.get("nodeProp2", "nodeProp2Value").hasNext());
assertEquals(node2, nodeAutoIndex.get("nodeProp2", "nodeProp2Value2").getSingle());
/*
* node3 is still there, despite its nodeProp1 property not being monitored
* any more because it was not touched, contrary to node1.
*/
assertEquals(node3, nodeAutoIndex.get("nodeProp1", "nodeProp3Value").getSingle());
// Finally, node4 is removed because the property was removed.
assertFalse(nodeAutoIndex.get("nodeProp2", "nodeProp4Value").hasNext());
// END SNIPPET: Mutations
transaction.finish();
}