//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSeeNewLabeledNodeInTransaction() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldSeeNewLabeledNodeInTransaction() { long nodeId; int labelId; const string labelName = "Town"; using (Transaction tx = beginTransaction()) { nodeId = tx.DataWrite().nodeCreate(); labelId = tx.Token().labelGetOrCreateForName(labelName); tx.DataWrite().nodeAddLabel(nodeId, labelId); using (NodeCursor node = tx.Cursors().allocateNodeCursor()) { tx.DataRead().singleNode(nodeId, node); assertTrue("should access node", node.Next()); LabelSet labels = node.Labels(); assertEquals(1, labels.NumberOfLabels()); assertEquals(labelId, labels.Label(0)); assertTrue(node.HasLabel(labelId)); assertFalse(node.HasLabel(labelId + 1)); assertFalse("should only find one node", node.Next()); } tx.Success(); } using (Org.Neo4j.Graphdb.Transaction ignore = graphDb.beginTx()) { assertThat(graphDb.getNodeById(nodeId).Labels, equalTo(Iterables.iterable(label(labelName)))); } }
private void ScanEverythingBelongingToNodes(NodeMappings nodeMappings) { using (NodeCursor nodeCursor = _cursors.allocateNodeCursor(), PropertyCursor propertyCursor = _cursors.allocatePropertyCursor()) { _dataRead.allNodesScan(nodeCursor); while (nodeCursor.Next()) { // each node SortedLabels labels = SortedLabels.From(nodeCursor.Labels()); nodeCursor.Properties(propertyCursor); MutableIntSet propertyIds = IntSets.mutable.empty(); while (propertyCursor.Next()) { Value currentValue = propertyCursor.PropertyValue(); int propertyKeyId = propertyCursor.PropertyKey(); Pair <SortedLabels, int> key = Pair.of(labels, propertyKeyId); UpdateValueTypeInMapping(currentValue, key, nodeMappings.LabelSetANDNodePropertyKeyIdToValueType); propertyIds.add(propertyKeyId); } propertyCursor.Close(); MutableIntSet oldPropertyKeySet = nodeMappings.LabelSetToPropertyKeys.getOrDefault(labels, _emptyPropertyIdSet); // find out which old properties we did not visited and mark them as nullable if (oldPropertyKeySet == _emptyPropertyIdSet) { if (propertyIds.size() == 0) { // Even if we find property key on other nodes with those labels, set all of them nullable nodeMappings.NullableLabelSets.Add(labels); } propertyIds.addAll(oldPropertyKeySet); } else { MutableIntSet currentPropertyIdsHelperSet = new IntHashSet(propertyIds.size()); currentPropertyIdsHelperSet.addAll(propertyIds); propertyIds.removeAll(oldPropertyKeySet); // only the brand new ones in propIds now oldPropertyKeySet.removeAll(currentPropertyIdsHelperSet); // only the old ones that are not on the new node propertyIds.addAll(oldPropertyKeySet); propertyIds.forEach(id => { Pair <SortedLabels, int> key = Pair.of(labels, id); nodeMappings.LabelSetANDNodePropertyKeyIdToValueType[key].setNullable(); }); propertyIds.addAll(currentPropertyIdsHelperSet); } nodeMappings.LabelSetToPropertyKeys[labels] = propertyIds; } nodeCursor.Close(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldAllowManyLabelsAndPropertyCursor() public virtual void ShouldAllowManyLabelsAndPropertyCursor() { int propertyCount = 10; int labelCount = 15; GraphDatabaseAPI db = DbRule.GraphDatabaseAPI; Node node; using (Transaction tx = Db.beginTx()) { node = Db.createNode(); for (int i = 0; i < propertyCount; i++) { node.SetProperty("foo" + i, "bar"); } for (int i = 0; i < labelCount; i++) { node.AddLabel(label("label" + i)); } tx.Success(); } ISet <int> seenProperties = new HashSet <int>(); ISet <int> seenLabels = new HashSet <int>(); using (Transaction tx = Db.beginTx()) { DependencyResolver resolver = Db.DependencyResolver; ThreadToStatementContextBridge bridge = resolver.ResolveDependency(typeof(ThreadToStatementContextBridge)); KernelTransaction ktx = bridge.GetKernelTransactionBoundToThisThread(true); using (NodeCursor nodes = ktx.Cursors().allocateNodeCursor(), PropertyCursor propertyCursor = ktx.Cursors().allocatePropertyCursor()) { ktx.DataRead().singleNode(node.Id, nodes); while (nodes.Next()) { nodes.Properties(propertyCursor); while (propertyCursor.Next()) { seenProperties.Add(propertyCursor.PropertyKey()); } LabelSet labels = nodes.Labels(); for (int i = 0; i < labels.NumberOfLabels(); i++) { seenLabels.Add(labels.Label(i)); } } } tx.Success(); } assertEquals(propertyCount, seenProperties.Count); assertEquals(labelCount, seenLabels.Count); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSeeLabelChangesInTransaction() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldSeeLabelChangesInTransaction() { long nodeId; int toRetain, toDelete, toAdd, toRegret; const string toRetainName = "ToRetain"; const string toDeleteName = "ToDelete"; const string toAddName = "ToAdd"; const string toRegretName = "ToRegret"; using (Transaction tx = beginTransaction()) { nodeId = tx.DataWrite().nodeCreate(); toRetain = tx.Token().labelGetOrCreateForName(toRetainName); toDelete = tx.Token().labelGetOrCreateForName(toDeleteName); tx.DataWrite().nodeAddLabel(nodeId, toRetain); tx.DataWrite().nodeAddLabel(nodeId, toDelete); tx.Success(); } using (Org.Neo4j.Graphdb.Transaction ignore = graphDb.beginTx()) { assertThat(graphDb.getNodeById(nodeId).Labels, containsInAnyOrder(label(toRetainName), label(toDeleteName))); } using (Transaction tx = beginTransaction()) { toAdd = tx.Token().labelGetOrCreateForName(toAddName); tx.DataWrite().nodeAddLabel(nodeId, toAdd); tx.DataWrite().nodeRemoveLabel(nodeId, toDelete); toRegret = tx.Token().labelGetOrCreateForName(toRegretName); tx.DataWrite().nodeAddLabel(nodeId, toRegret); tx.DataWrite().nodeRemoveLabel(nodeId, toRegret); using (NodeCursor node = tx.Cursors().allocateNodeCursor()) { tx.DataRead().singleNode(nodeId, node); assertTrue("should access node", node.Next()); AssertLabels(node.Labels(), toRetain, toAdd); assertTrue(node.HasLabel(toAdd)); assertTrue(node.HasLabel(toRetain)); assertFalse(node.HasLabel(toDelete)); assertFalse(node.HasLabel(toRegret)); assertFalse("should only find one node", node.Next()); } tx.Success(); } using (Org.Neo4j.Graphdb.Transaction ignored = graphDb.beginTx()) { assertThat(graphDb.getNodeById(nodeId).Labels, containsInAnyOrder(label(toRetainName), label(toAddName))); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldReadLabels() public virtual void ShouldReadLabels() { // given using (NodeCursor nodes = cursors.allocateNodeCursor()) { LabelSet labels; // when read.singleNode(_foo, nodes); // then assertTrue("should access defined node", nodes.Next()); labels = nodes.Labels(); assertEquals("number of labels", 1, labels.NumberOfLabels()); int fooLabel = labels.Label(0); assertTrue(nodes.HasLabel(fooLabel)); assertFalse("should only access a single node", nodes.Next()); // when read.singleNode(_bar, nodes); // then assertTrue("should access defined node", nodes.Next()); labels = nodes.Labels(); assertEquals("number of labels", 1, labels.NumberOfLabels()); int barLabel = labels.Label(0); assertFalse(nodes.HasLabel(fooLabel)); assertTrue(nodes.HasLabel(barLabel)); assertFalse("should only access a single node", nodes.Next()); // when read.singleNode(_baz, nodes); // then assertTrue("should access defined node", nodes.Next()); labels = nodes.Labels(); assertEquals("number of labels", 1, labels.NumberOfLabels()); int bazLabel = labels.Label(0); assertFalse(nodes.HasLabel(fooLabel)); assertFalse(nodes.HasLabel(barLabel)); assertTrue(nodes.HasLabel(bazLabel)); assertFalse("should only access a single node", nodes.Next()); assertNotEquals("distinct labels", fooLabel, barLabel); assertNotEquals("distinct labels", fooLabel, bazLabel); assertNotEquals("distinct labels", barLabel, bazLabel); // when read.singleNode(_barbaz, nodes); // then assertTrue("should access defined node", nodes.Next()); labels = nodes.Labels(); assertEquals("number of labels", 2, labels.NumberOfLabels()); if (labels.Label(0) == barLabel) { assertEquals(bazLabel, labels.Label(1)); } else { assertEquals(bazLabel, labels.Label(0)); assertEquals(barLabel, labels.Label(1)); } assertFalse(nodes.HasLabel(fooLabel)); assertTrue(nodes.HasLabel(barLabel)); assertTrue(nodes.HasLabel(bazLabel)); assertFalse("should only access a single node", nodes.Next()); // when read.singleNode(_bare, nodes); // then assertTrue("should access defined node", nodes.Next()); labels = nodes.Labels(); assertEquals("number of labels", 0, labels.NumberOfLabels()); assertFalse(nodes.HasLabel(fooLabel)); assertFalse(nodes.HasLabel(barLabel)); assertFalse(nodes.HasLabel(bazLabel)); assertFalse("should only access a single node", nodes.Next()); } }