//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void requirePropertyFromMultipleNodeKeys()
public virtual void RequirePropertyFromMultipleNodeKeys()
{
Label label = Label.label("multiNodeKeyLabel");
SchemaHelper.createNodeKeyConstraint(Db, label, "property1", "property2");
SchemaHelper.createNodeKeyConstraint(Db, label, "property2", "property3");
SchemaHelper.createNodeKeyConstraint(Db, label, "property3", "property4");
assertException(() =>
{
using (Org.Neo4j.Graphdb.Transaction transaction = Db.beginTx())
{
Node node = Db.createNode(label);
node.setProperty("property1", "1");
node.setProperty("property2", "2");
transaction.Success();
}
}, typeof(ConstraintViolationException), "Node(0) with label `multiNodeKeyLabel` must have the properties `property2, property3`");
assertException(() =>
{
using (Org.Neo4j.Graphdb.Transaction transaction = Db.beginTx())
{
Node node = Db.createNode(label);
node.setProperty("property1", "1");
node.setProperty("property2", "2");
node.setProperty("property3", "3");
transaction.Success();
}
}, typeof(ConstraintViolationException), "Node(1) with label `multiNodeKeyLabel` must have the properties `property3, property4`");
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void compositeNodeKeyConstraintUpdate() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void CompositeNodeKeyConstraintUpdate()
{
GraphDatabaseService database = (new EnterpriseGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(TestDirectory.storeDir()).setConfig(OnlineBackupSettings.online_backup_enabled, Settings.FALSE).newGraphDatabase();
Label label = Label.label("label");
using (Transaction transaction = database.BeginTx())
{
Node node = database.CreateNode(label);
node.SetProperty("b", ( short )3);
node.SetProperty("a", new double[] { 0.6, 0.4, 0.2 });
transaction.Success();
}
using (Transaction transaction = database.BeginTx())
{
string query = format("CREATE CONSTRAINT ON (n:%s) ASSERT (n.%s,n.%s) IS NODE KEY", label.Name(), "a", "b");
database.Execute(query);
transaction.Success();
}
AwaitIndex(database);
using (Transaction transaction = database.BeginTx())
{
Node node = database.CreateNode(label);
node.SetProperty("a", ( short )7);
node.SetProperty("b", new double[] { 0.7, 0.5, 0.3 });
transaction.Success();
}
database.Shutdown();
ConsistencyCheckService.Result consistencyCheckResult = CheckDbConsistency(TestDirectory.storeDir());
assertTrue("Database is consistent", consistencyCheckResult.Successful);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void validateExplicitIndexedRelationshipProperties()
internal virtual void ValidateExplicitIndexedRelationshipProperties()
{
setUp();
Label label = Label.label("explicitIndexedRelationshipPropertiesTestLabel");
string propertyName = "explicitIndexedRelationshipProperties";
string explicitIndexedRelationshipIndex = "explicitIndexedRelationshipIndex";
RelationshipType indexType = RelationshipType.withName("explicitIndexType");
using (Transaction transaction = _database.beginTx())
{
Node source = _database.createNode(label);
Node destination = _database.createNode(label);
Relationship relationship = source.CreateRelationshipTo(destination, indexType);
_database.index().forRelationships(explicitIndexedRelationshipIndex).add(relationship, propertyName, "shortString");
transaction.Success();
}
System.ArgumentException argumentException = assertThrows(typeof(System.ArgumentException), () =>
{
using (Transaction transaction = _database.beginTx())
{
Node source = _database.createNode(label);
Node destination = _database.createNode(label);
Relationship relationship = source.createRelationshipTo(destination, indexType);
string longValue = StringUtils.repeat("a", IndexWriter.MAX_TERM_LENGTH + 1);
_database.index().forRelationships(explicitIndexedRelationshipIndex).add(relationship, propertyName, longValue);
transaction.Success();
}
});
assertEquals("Property value size is too large for index. Please see index documentation for limitations.", argumentException.Message);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCreateACountsStoreWhenThereAreUnusedNodeRecordsInTheDB()
public virtual void ShouldCreateACountsStoreWhenThereAreUnusedNodeRecordsInTheDB()
{
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("deprecation") final org.neo4j.kernel.internal.GraphDatabaseAPI db = (org.neo4j.kernel.internal.GraphDatabaseAPI) dbBuilder.newGraphDatabase();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
GraphDatabaseAPI db = ( GraphDatabaseAPI )_dbBuilder.newGraphDatabase();
using (Transaction tx = Db.beginTx())
{
Db.createNode(Label.label("A"));
Db.createNode(Label.label("C"));
Node node = Db.createNode(Label.label("D"));
Db.createNode();
node.Delete();
tx.Success();
}
long lastCommittedTransactionId = GetLastTxId(db);
Db.shutdown();
RebuildCounts(lastCommittedTransactionId);
using (Lifespan life = new Lifespan())
{
CountsTracker store = life.Add(CreateCountsTracker());
assertEquals(BASE_TX_ID + 1 + 1 + 1 + 1, store.TxId());
assertEquals(3, store.TotalEntriesStored());
assertEquals(3, Get(store, nodeKey(-1)));
assertEquals(1, Get(store, nodeKey(0)));
assertEquals(1, Get(store, nodeKey(1)));
assertEquals(0, Get(store, nodeKey(2)));
assertEquals(0, Get(store, nodeKey(3)));
}
}
private int LabelId(Label alien)
{
using (Transaction ignore = _db.beginTx())
{
return(Ktx().tokenRead().nodeLabel(alien.Name()));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldPropagateRelationshipCountsInHA() throws org.neo4j.internal.kernel.api.exceptions.TransactionFailureException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldPropagateRelationshipCountsInHA()
{
ManagedCluster cluster = ClusterRule.startCluster();
HighlyAvailableGraphDatabase master = cluster.Master;
using (Transaction tx = master.BeginTx())
{
Node left = master.CreateNode();
Node right = master.CreateNode(Label.label("A"));
left.CreateRelationshipTo(right, RelationshipType.withName("Type"));
tx.Success();
}
cluster.Sync();
foreach (HighlyAvailableGraphDatabase db in cluster.AllMembers)
{
using ([email protected] tx = Db.DependencyResolver.resolveDependency(typeof(Kernel)).beginTransaction(@explicit, AUTH_DISABLED))
{
assertEquals(1, tx.dataRead().countsForRelationship(-1, -1, -1));
assertEquals(1, tx.dataRead().countsForRelationship(-1, -1, 0));
assertEquals(1, tx.dataRead().countsForRelationship(-1, 0, -1));
assertEquals(1, tx.dataRead().countsForRelationship(-1, 0, 0));
}
}
}
/// <summary>
/// Reading a node command might leave a node record which referred to
/// labels in one or more dynamic records as marked as heavy even if that
/// node already had references to dynamic records, changed in a transaction,
/// but had no labels on that node changed within that same transaction.
/// Now defensively only marks as heavy if there were one or more dynamic
/// records provided when providing the record object with the label field
/// value. This would give the opportunity to load the dynamic records the
/// next time that record would be ensured heavy.
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRecoverNodeWithDynamicLabelRecords()
public virtual void ShouldRecoverNodeWithDynamicLabelRecords()
{
// GIVEN
_database = (new TestGraphDatabaseFactory()).setFileSystem(Fs).newImpermanentDatabase();
Node node;
Label[] labels = new Label[] { label("a"), label("b"), label("c"), label("d"), label("e"), label("f"), label("g"), label("h"), label("i"), label("j"), label("k") };
using (Transaction tx = _database.beginTx())
{
node = _database.createNode(labels);
tx.Success();
}
// WHEN
using (Transaction tx = _database.beginTx())
{
node.SetProperty("prop", "value");
tx.Success();
}
EphemeralFileSystemAbstraction snapshot = Fs.snapshot();
_database.shutdown();
_database = (new TestGraphDatabaseFactory()).setFileSystem(snapshot).newImpermanentDatabase();
// THEN
using (Transaction ignored = _database.beginTx())
{
node = _database.getNodeById(node.Id);
foreach (Label label in labels)
{
assertTrue(node.HasLabel(label));
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void uniqueIndexSeekDoNotLeakIndexReaders() throws org.neo4j.internal.kernel.api.exceptions.KernelException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void UniqueIndexSeekDoNotLeakIndexReaders()
{
TrackingIndexExtensionFactory indexExtensionFactory = new TrackingIndexExtensionFactory();
GraphDatabaseAPI database = CreateDatabase(indexExtensionFactory);
try
{
Label label = label("spaceship");
string nameProperty = "name";
CreateUniqueConstraint(database, label, nameProperty);
GenerateRandomData(database, label, nameProperty);
assertNotNull(indexExtensionFactory.IndexProvider);
assertThat(numberOfClosedReaders(), greaterThan(0L));
assertThat(numberOfOpenReaders(), greaterThan(0L));
assertThat(numberOfClosedReaders(), CloseTo(numberOfOpenReaders(), 1));
LockNodeUsingUniqueIndexSeek(database, label, nameProperty);
assertThat(numberOfClosedReaders(), CloseTo(numberOfOpenReaders(), 1));
}
finally
{
database.Shutdown();
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void validateNodePropertiesOnPopulation()
internal virtual void ValidateNodePropertiesOnPopulation()
{
setUp();
Label label = Label.label("populationTestNodeLabel");
string propertyName = "populationTestPropertyName";
using (Transaction transaction = _database.beginTx())
{
Node node = _database.createNode(label);
node.SetProperty(propertyName, StringUtils.repeat("a", IndexWriter.MAX_TERM_LENGTH + 1));
transaction.Success();
}
IndexDefinition indexDefinition = CreateIndex(label, propertyName);
try
{
using (Transaction ignored = _database.beginTx())
{
_database.schema().awaitIndexesOnline(5, TimeUnit.MINUTES);
}
}
catch (System.InvalidOperationException)
{
using (Transaction ignored = _database.beginTx())
{
string indexFailure = _database.schema().getIndexFailure(indexDefinition);
assertThat(indexFailure, allOf(containsString("java.lang.IllegalArgumentException:"), containsString("Please see index documentation for limitations.")));
}
}
}
public static System.Func <Node, Node> AddLabel(Label label)
{
return(node =>
{
node.addLabel(label);
return node;
});
}
public static System.Func <GraphDatabaseService, Void> Index(Label label, string propertyKey)
{
return(graphDb =>
{
graphDb.schema().indexFor(label).on(propertyKey).create();
return null;
});
}
public static System.Func <GraphDatabaseService, Void> UniquenessConstraint(Label label, string propertyKey)
{
return(graphDb =>
{
graphDb.schema().constraintFor(label).assertPropertyIsUnique(propertyKey).create();
return null;
});
}
private static long GetLabelId(HighlyAvailableGraphDatabase db, Label label)
{
using (Transaction ignore = Db.beginTx())
{
ThreadToStatementContextBridge bridge = ThreadToStatementContextBridgeFrom(db);
return(bridge.GetKernelTransactionBoundToThisThread(true).tokenRead().nodeLabel(label.Name()));
}
}
protected internal NodeConstraintDefinition(InternalSchemaActions actions, IndexDefinition indexDefinition) : base(actions, indexDefinition)
{
if (indexDefinition.MultiTokenIndex)
{
throw new System.ArgumentException("Node constraints do not support multi-token definitions. That is, they cannot apply to more than one label, " + "but an attempt was made to create a node constraint on the following labels: " + labelNameList(indexDefinition.Labels, "", "."));
}
this.LabelConflict = single(indexDefinition.Labels);
}
/// <summary>
/// Transactional version of <seealso cref="countsForRelationship(Label, RelationshipType, Label)"/> </summary>
private long NumberOfRelationshipsMatching(Label lhs, RelationshipType type, Label rhs)
{
using (Transaction tx = Db.GraphDatabaseAPI.beginTx())
{
long nodeCount = CountsForRelationship(lhs, type, rhs);
tx.Success();
return(nodeCount);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldUpdateRelationshipWithLabelCountsWhenDeletingNodesWithRelationships()
public virtual void ShouldUpdateRelationshipWithLabelCountsWhenDeletingNodesWithRelationships()
{
// given
int numberOfNodes = 2;
Node[] nodes = new Node[numberOfNodes];
using (Transaction tx = Db.beginTx())
{
for (int i = 0; i < numberOfNodes; i++)
{
Node foo = Db.createNode(label("Foo" + i));
foo.AddLabel(Label.label("Common"));
Node bar = Db.createNode(label("Bar" + i));
foo.CreateRelationshipTo(bar, withName("BAZ" + i));
nodes[i] = foo;
}
tx.Success();
}
long[] beforeCommon = new long[numberOfNodes];
long[] before = new long[numberOfNodes];
for (int i = 0; i < numberOfNodes; i++)
{
beforeCommon[i] = NumberOfRelationshipsMatching(label("Common"), withName("BAZ" + i), null);
before[i] = NumberOfRelationshipsMatching(label("Foo" + i), withName("BAZ" + i), null);
}
// when
using (Transaction tx = Db.beginTx())
{
foreach (Node node in nodes)
{
foreach (Relationship relationship in node.Relationships)
{
relationship.Delete();
}
node.Delete();
}
tx.Success();
}
long[] afterCommon = new long[numberOfNodes];
long[] after = new long[numberOfNodes];
for (int i = 0; i < numberOfNodes; i++)
{
afterCommon[i] = NumberOfRelationshipsMatching(label("Common"), withName("BAZ" + i), null);
after[i] = NumberOfRelationshipsMatching(label("Foo" + i), withName("BAZ" + i), null);
}
// then
for (int i = 0; i < numberOfNodes; i++)
{
assertEquals(beforeCommon[i] - 1, afterCommon[i]);
assertEquals(before[i] - 1, after[i]);
}
}
/// <summary>
/// Transactional version of <seealso cref="countsForRelationship(Label, RelationshipType, Label)"/>
/// </summary>
private MatchingRelationships NumberOfRelationshipsMatching(Label lhs, RelationshipType type, Label rhs)
{
using (Transaction tx = Db.GraphDatabaseAPI.beginTx())
{
long nodeCount = CountsForRelationship(lhs, type, rhs);
tx.Success();
return(new MatchingRelationships(string.Format("({0})-{1}->({2})", lhs == null ? "" : ":" + lhs.Name(), type == null ? "" : "[:" + type.Name() + "]", rhs == null ? "" : ":" + rhs.Name()), nodeCount));
}
}
private static long NumberOfNodesHavingLabel(GraphDatabaseService db, Label label)
{
using (Transaction tx = Db.beginTx())
{
long count = count(Db.findNodes(label));
tx.Success();
return(count);
}
}
private static void CreateANode(HighlyAvailableGraphDatabase db, Label label, string value, string property)
{
using (Transaction tx = Db.beginTx())
{
Node node = Db.createNode(label);
node.SetProperty(property, value);
tx.Success();
}
}
/// <summary>
/// Transactional version of <seealso cref="countsForNode(Label)"/> </summary>
private long NumberOfNodesWith(Label label)
{
using (Transaction tx = Db.GraphDatabaseAPI.beginTx())
{
long nodeCount = CountsForNode(label);
tx.Success();
return(nodeCount);
}
}
private IndexDefinition CreateIndex(Label label, string propertyName)
{
using (Transaction transaction = _database.beginTx())
{
IndexDefinition indexDefinition = _database.schema().indexFor(label).on(propertyName).create();
transaction.Success();
return(indexDefinition);
}
}
private void CreateData()
{
Label label = Label.label("toRetry");
using (Transaction transaction = _database.beginTx())
{
Node node = _database.createNode(label);
node.SetProperty("c", "d");
transaction.Success();
}
}
private static void GenerateRandomData(GraphDatabaseAPI database, Label label, string nameProperty)
{
for (int i = 0; i < 1000; i++)
{
using (Transaction transaction = database.BeginTx())
{
Node node = database.CreateNode(label);
node.SetProperty(nameProperty, "PlanetExpress" + i);
transaction.Success();
}
}
}
private GraphDatabaseService PrepareDb(Label label, string propertyName, LogProvider logProvider)
{
GraphDatabaseService db = GetDatabase(logProvider);
using (Transaction transaction = Db.beginTx())
{
Db.schema().constraintFor(label).assertPropertyIsUnique(propertyName).create();
transaction.Success();
}
WaitIndexes(db);
return(db);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private static org.neo4j.kernel.impl.util.Listener<org.neo4j.graphdb.GraphDatabaseService> uniquenessConstraint(final org.neo4j.graphdb.Label label, final String propertyKey)
private static Listener <GraphDatabaseService> UniquenessConstraint(Label label, string propertyKey)
{
return(db =>
{
using (Transaction tx = Db.beginTx())
{
Db.schema().constraintFor(label).assertPropertyIsUnique(propertyKey).create();
tx.success();
}
});
}
private static void CreateUniqueConstraint(GraphDatabaseAPI database, Label label, string nameProperty)
{
using (Transaction transaction = database.BeginTx())
{
database.Schema().constraintFor(label).assertPropertyIsUnique(nameProperty).create();
transaction.Success();
}
using (Transaction transaction = database.BeginTx())
{
database.Schema().awaitIndexesOnline(1, TimeUnit.MINUTES);
transaction.Success();
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void startStopDatabaseWithIndex()
public virtual void StartStopDatabaseWithIndex()
{
Label label = Label.label("string");
string property = "property";
AssertableLogProvider logProvider = new AssertableLogProvider(true);
GraphDatabaseService db = PrepareDb(label, property, logProvider);
Db.shutdown();
db = GetDatabase(logProvider);
Db.shutdown();
logProvider.FormattedMessageMatcher().assertNotContains("Failed to open index");
}
public override void Perform(long nodeId, string value)
{
Node node = _db.getNodeById(nodeId);
Label label = Label.label(value);
if (node.HasLabel(label))
{
node.RemoveLabel(label);
}
else
{
node.AddLabel(label);
}
}
/// <param name="start"> the label of the start node of relationships to get the number of, or {@code null} for "any". </param>
/// <param name="type"> the type of the relationships to get the number of, or {@code null} for "any". </param>
/// <param name="end"> the label of the end node of relationships to get the number of, or {@code null} for "any". </param>
private long CountsForRelationship(Label start, RelationshipType type, Label end)
{
KernelTransaction ktx = _ktxSupplier.get();
using (Statement ignore = ktx.AcquireStatement())
{
TokenRead tokenRead = ktx.TokenRead();
int startId;
int typeId;
int endId;
// start
if (start == null)
{
startId = [email protected]_Fields.ANY_LABEL;
}
else
{
if ([email protected]_Fields.NO_TOKEN == (startId = tokenRead.NodeLabel(start.Name())))
{
return(0);
}
}
// type
if (type == null)
{
typeId = [email protected]_Fields.ANY_RELATIONSHIP_TYPE;
}
else
{
if ([email protected]_Fields.NO_TOKEN == (typeId = tokenRead.RelationshipType(type.Name())))
{
return(0);
}
}
// end
if (end == null)
{
endId = [email protected]_Fields.ANY_LABEL;
}
else
{
if ([email protected]_Fields.NO_TOKEN == (endId = tokenRead.NodeLabel(end.Name())))
{
return(0);
}
}
return(ktx.DataRead().countsForRelationship(startId, typeId, endId));
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static void lockNodeUsingUniqueIndexSeek(org.neo4j.kernel.internal.GraphDatabaseAPI database, org.neo4j.graphdb.Label label, String nameProperty) throws org.neo4j.internal.kernel.api.exceptions.KernelException
private static void LockNodeUsingUniqueIndexSeek(GraphDatabaseAPI database, Label label, string nameProperty)
{
using (Transaction transaction = database.BeginTx())
{
ThreadToStatementContextBridge contextBridge = database.DependencyResolver.resolveDependency(typeof(ThreadToStatementContextBridge));
KernelTransaction kernelTransaction = contextBridge.GetKernelTransactionBoundToThisThread(true);
TokenRead tokenRead = kernelTransaction.TokenRead();
Read dataRead = kernelTransaction.DataRead();
int labelId = tokenRead.NodeLabel(label.Name());
int propertyId = tokenRead.PropertyKey(nameProperty);
IndexReference indexReference = kernelTransaction.SchemaRead().index(labelId, propertyId);
dataRead.LockingNodeUniqueIndexSeek(indexReference, IndexQuery.ExactPredicate.exact(propertyId, "value"));
transaction.Success();
}
}
