@Test
public void shouldLoadAllRelationships() throws Exception {
// GIVEN
GraphDatabaseAPI db = getGraphDbAPI();
Node node;
try (Transaction tx = db.beginTx()) {
node = db.createNode();
for (int i = 0; i < 112; i++) {
node.createRelationshipTo(db.createNode(), MyRelTypes.TEST);
db.createNode().createRelationshipTo(node, MyRelTypes.TEST);
}
tx.success();
}
// WHEN
db.getDependencyResolver().resolveDependency(NodeManager.class).clearCache();
int one, two;
try (Transaction tx = db.beginTx()) {
one = count(node.getRelationships(MyRelTypes.TEST, Direction.OUTGOING));
two = count(node.getRelationships(MyRelTypes.TEST, Direction.OUTGOING));
tx.success();
}
// THEN
assertEquals(two, one);
}
public static void main(String[] args) throws IOException {
GraphDatabaseAPI db = (GraphDatabaseAPI) new GraphDatabaseFactory().newEmbeddedDatabase(dir);
Transaction tx = db.beginTx();
db.createNode().createRelationshipTo(db.createNode(), MyRelTypes.TEST);
tx.success();
tx.close();
db.getDependencyResolver().resolveDependency(LogRotation.class).rotateLogFile();
tx = db.beginTx();
db.index().forNodes("index").add(db.createNode(), dir, db.createNode());
tx.success();
tx.close();
exit(0);
}
protected Relationship[] createRelationshipChain(RelationshipType type, int length) {
try (Transaction transaction = db.beginTx()) {
Relationship[] relationshipChain = createRelationshipChain(db.createNode(), type, length);
transaction.success();
return relationshipChain;
}
}
private void setSuccess(GraphDatabaseAPI graphdb, boolean success) {
try (Transaction tx = graphdb.beginTx()) {
Node node = graphdb.createNode();
node.setProperty("success", success);
tx.success();
}
}
private void createARelationship(GraphDatabaseAPI db) {
Transaction tx = db.beginTx();
Node node1 = db.createNode();
Node node2 = db.createNode();
node1.createRelationshipTo(node2, withName("friend"));
tx.success();
tx.finish();
}
@Override
public void run(GraphDatabaseAPI graphdb) {
try (Transaction tx = graphdb.beginTx()) {
for (int i = 0; i < 3; i++)
graphdb.index().forNodes("index" + i).add(graphdb.createNode(), "name", "" + i);
tx.success();
}
}
long createNode() {
GraphDatabaseAPI graphdb = server().getDatabase().getGraph();
try (Transaction tx = graphdb.beginTx()) {
Node node = graphdb.createNode();
tx.success();
return node.getId();
}
}
private void doTransaction() {
Transaction tx = db.beginTx();
try {
db.createNode();
tx.success();
} finally {
tx.finish();
}
}
private Relationship createRelationshipAndLoadFresh(Map<String, Object> properties) {
Relationship relationship = null;
Transaction tx = db.beginTx();
try {
relationship = db.createNode().createRelationshipTo(db.createNode(), MyRelTypes.TEST);
setProperties(properties, relationship);
tx.success();
} finally {
tx.finish();
}
clearCache();
if (!properties.isEmpty()) {
loadProperties(relationship);
}
return relationship;
}
private Node createNodeAndLoadFresh(
Map<String, Object> properties, int nrOfRelationships, int nrOfTypes, int directionStride) {
Node node = null;
Transaction tx = db.beginTx();
try {
node = db.createNode();
setProperties(properties, node);
for (int t = 0; t < nrOfTypes; t++) {
RelationshipType type = DynamicRelationshipType.withName(relTypeName(t));
for (int i = 0, dir = 0; i < nrOfRelationships; i++, dir = (dir + directionStride) % 3) {
switch (dir) {
case 0:
node.createRelationshipTo(db.createNode(), type);
break;
case 1:
db.createNode().createRelationshipTo(node, type);
break;
case 2:
node.createRelationshipTo(node, type);
break;
default:
throw new IllegalArgumentException("Invalid direction " + dir);
}
}
}
tx.success();
} finally {
tx.finish();
}
clearCache();
if (!properties.isEmpty()) {
loadProperties(node);
}
if (nrOfRelationships * nrOfTypes > 0) {
countRelationships(node);
}
return node;
}
private long createNode(Label label, int number)
throws PropertyKeyNotFoundException, LabelNotFoundKernelException {
Transaction tx = db.beginTx();
try {
Node node = db.createNode(label);
node.setProperty(NUM_BANANAS_KEY, number);
tx.success();
return node.getId();
} finally {
tx.finish();
}
}
protected Relationship[] createRelationshipChain(
Node startingFromNode, RelationshipType type, int length) {
try (Transaction tx = db.beginTx()) {
Relationship[] rels = new Relationship[length];
Node firstNode = startingFromNode;
for (int i = 0; i < rels.length; i++) {
Node secondNode = db.createNode();
rels[i] = firstNode.createRelationshipTo(secondNode, type);
firstNode = secondNode;
}
tx.success();
return rels;
}
}
private Node createNodeWithRelationships(GraphDatabaseAPI db) {
Transaction tx = db.beginTx();
Node node;
try {
node = db.createNode();
for (int i = 0; i < relCount / 2; i++) {
node.createRelationshipTo(node, MyRelTypes.TEST);
}
for (int i = 0; i < relCount / 2; i++) {
node.createRelationshipTo(node, MyRelTypes.TEST2);
}
tx.success();
return node;
} finally {
tx.finish();
}
}
@Override
public void run(GraphDatabaseAPI graphdb) {
Transaction tx = graphdb.beginTx();
Node node;
try { // hack to get around another bug
node = graphdb.createNode();
tx.success();
} finally {
tx.finish();
}
tx = graphdb.beginTx();
try {
node.setProperty("correct", "yes");
graphdb.index().forNodes("nodes").add(node, "name", "value");
tx.success();
} finally {
tx.finish();
}
}
@Test
public void shouldHandleLargeAmountsOfNodesAddedAndRemovedInSameTx() throws Exception {
// Given
GraphDatabaseAPI db = dbRule.getGraphDatabaseAPI();
int labelsToAdd = 80;
int labelsToRemove = 40;
// When
Node node;
try (Transaction tx = db.beginTx()) {
node = db.createNode();
// I create a lot of labels, enough to push the store to use two dynamic records
for (int l = 0; l < labelsToAdd; l++) {
node.addLabel(label("Label-" + l));
}
// and I delete some of them, enough to bring the number of dynamic records needed down to 1
for (int l = 0; l < labelsToRemove; l++) {
node.removeLabel(label("Label-" + l));
}
tx.success();
}
// Then
try (Transaction ignore = db.beginTx()) {
// All the labels remaining should be in the label scan store
for (int l = labelsToAdd - 1; l >= labelsToRemove; l--) {
Label label = label("Label-" + l);
assertThat(
"Should have founnd node when looking for label " + label,
single(GlobalGraphOperations.at(db).getAllNodesWithLabel(label)),
equalTo(node));
}
}
}
@Test
public void firstRecordOtherThanZeroIfNotFirst() throws Exception {
String storeDir = forTest(getClass()).cleanDirectory("zero").getAbsolutePath();
GraphDatabaseAPI db = (GraphDatabaseAPI) factory.newImpermanentDatabase(storeDir);
Transaction tx = db.beginTx();
Node node = db.createNode();
node.setProperty("name", "Yo");
tx.success();
tx.finish();
db.shutdown();
db = (GraphDatabaseAPI) factory.newImpermanentDatabase(storeDir);
tx = db.beginTx();
properties(db).setProperty("test", "something");
tx.success();
tx.finish();
db.shutdown();
Config config =
configForStoreDir(
new Config(Collections.<String, String>emptyMap(), GraphDatabaseSettings.class),
new File(storeDir));
Monitors monitors = new Monitors();
StoreFactory storeFactory =
new StoreFactory(
config,
new DefaultIdGeneratorFactory(),
pageCacheRule.getPageCache(fs.get(), config),
fs.get(),
StringLogger.DEV_NULL,
monitors);
NeoStore neoStore = storeFactory.newNeoStore(false);
long prop = neoStore.getGraphNextProp();
assertTrue(prop != 0);
neoStore.close();
}
private void createNode(GraphDatabaseAPI db) {
Transaction tx = db.beginTx();
db.createNode();
tx.success();
tx.finish();
}
private void createNode() {
try (Transaction tx = db.beginTx()) {
db.createNode();
tx.success();
}
}
