private boolean matches(Node node, String[] properties, Object[] values) {
for (int i = 0; i < properties.length; i++) {
if (node.hasProperty(properties[i]) && !node.getProperty(properties[i]).equals(values[i])) {
return false;
} else if (!node.hasProperty(properties[i]) && values[i] != null) {
return false;
}
}
return true;
}
@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 testNodeGetProperties() {
Node node1 = getGraphDb().getNodeById(node1Id);
assertTrue(!node1.hasProperty(null));
Iterator<Object> values = node1.getPropertyValues().iterator();
values.next();
values.next();
Iterator<String> keys = node1.getPropertyKeys().iterator();
keys.next();
keys.next();
assertTrue(node1.hasProperty(key1));
assertTrue(node1.hasProperty(key2));
}
@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"));
}
private boolean isNewlyCreatedPageNode(Node node) {
// Default isolation level is READ_COMMITTED, so the graph keeps keeps
// write locks on the node until the
// end of the transaction. Threads reusing a node should never see a
// half-constructed node.
return !node.hasProperty(PageNode.DOMAIN_KEY);
}
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 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 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 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 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 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 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 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));
}
/*
* 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 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 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));
}
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 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"));
}
@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 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 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"));
}
/**
* 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()));
}
@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 testTxCacheLoadIsolation() throws Exception {
Node node = getGraphDb().createNode();
node.setProperty("someproptest", "testing");
Node node1 = getGraphDb().createNode();
node1.setProperty("someotherproptest", 2);
commit();
EmbeddedGraphDatabase graphDb = (EmbeddedGraphDatabase) getGraphDb();
TransactionManager txManager = graphDb.getConfig().getTxModule().getTxManager();
NodeManager nodeManager = graphDb.getConfig().getGraphDbModule().getNodeManager();
txManager.begin();
node.setProperty("someotherproptest", "testing2");
Relationship rel = node.createRelationshipTo(node1, MyRelTypes.TEST);
javax.transaction.Transaction txA = txManager.suspend();
txManager.begin();
assertEquals("testing", node.getProperty("someproptest"));
assertTrue(!node.hasProperty("someotherproptest"));
assertTrue(!node.hasRelationship());
nodeManager.clearCache();
assertEquals("testing", node.getProperty("someproptest"));
assertTrue(!node.hasProperty("someotherproptest"));
javax.transaction.Transaction txB = txManager.suspend();
txManager.resume(txA);
assertEquals("testing", node.getProperty("someproptest"));
assertTrue(node.hasProperty("someotherproptest"));
assertTrue(node.hasRelationship());
nodeManager.clearCache();
assertEquals("testing", node.getProperty("someproptest"));
assertTrue(node.hasProperty("someotherproptest"));
assertTrue(node.hasRelationship());
txManager.suspend();
txManager.resume(txB);
assertEquals("testing", node.getProperty("someproptest"));
assertTrue(!node.hasProperty("someotherproptest"));
assertTrue(!node.hasRelationship());
txManager.rollback();
txManager.resume(txA);
node.delete();
node1.delete();
rel.delete();
txManager.commit();
newTransaction();
}
protected boolean hasPropertyValue(Node node, PropertyKey propertyKey, Object propertyValue) {
if (node != null && node.hasProperty(propertyKey.dbName())) {
Object value = node.getProperty(propertyKey.dbName());
return value.equals(propertyValue);
}
return false;
}
@Override
public QName getName() {
if (node.hasProperty(AbstractNode.TYPE_KEY)) {
String name = (String) node.getProperty(AbstractNode.TYPE_KEY);
// do some encoding
// name = XPathEncoder.encode(name);
return (new QName(name));
}
return (new QName(""));
}
/**
* Called when a relationship of this combinedType is instatiated. Please note that a relationship
* can (and will) be instantiated several times during a normal rendering turn.
*/
@Override
public void onRelationshipInstantiation() {
try {
if (dbRelationship != null) {
Node startNode = dbRelationship.getStartNode();
Node endNode = dbRelationship.getEndNode();
if ((startNode != null)
&& (endNode != null)
&& startNode.hasProperty(GraphObject.id.dbName())
&& endNode.hasProperty(GraphObject.id.dbName())) {
cachedStartNodeId = (String) startNode.getProperty(GraphObject.id.dbName());
cachedEndNodeId = (String) endNode.getProperty(GraphObject.id.dbName());
}
}
} catch (Throwable t) {
}
}
/**
* The index nodes do NOT belong to the domain model, and as such need to use the indexes internal
* knowledge of the index tree and node structure for decoding the envelope.
*/
protected Envelope getIndexNodeEnvelope(Node indexNode) {
if (indexNode == null) {
indexNode = getIndexRoot();
}
try (Transaction tx = database.beginTx()) {
if (!indexNode.hasProperty(INDEX_PROP_BBOX)) {
// this is ok after an index node split
tx.success();
return null;
}
double[] bbox = (double[]) indexNode.getProperty(INDEX_PROP_BBOX);
tx.success();
// Envelope parameters: xmin, xmax, ymin, ymax
return new Envelope(bbox[0], bbox[2], bbox[1], bbox[3]);
}
}
@Test
public void shouldBeAbleToRemoveNodeProperty() throws Exception {
Map<String, Object> properties = new HashMap<String, Object>();
properties.put("foo", "bar");
properties.put("number", 15);
long nodeId = createNode(properties);
actions.removeNodeProperty(nodeId, "foo");
Transaction tx = database.getGraph().beginTx();
try {
Node node = database.getGraph().getNodeById(nodeId);
assertEquals(15, node.getProperty("number"));
assertEquals(false, node.hasProperty("foo"));
tx.success();
} finally {
tx.finish();
}
}