//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static java.util.List<java.util.Map<String,Object>> indexes(org.neo4j.internal.kernel.api.TokenRead tokens, org.neo4j.internal.kernel.api.SchemaRead schemaRead, Anonymizer anonymizer) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException private static IList <IDictionary <string, object> > Indexes(TokenRead tokens, SchemaRead schemaRead, Anonymizer anonymizer) { IList <IDictionary <string, object> > indexes = new List <IDictionary <string, object> >(); SilentTokenNameLookup tokenLookup = new SilentTokenNameLookup(tokens); IEnumerator <IndexReference> iterator = schemaRead.IndexesGetAll(); while (iterator.MoveNext()) { IndexReference index = iterator.Current; IDictionary <string, object> data = new Dictionary <string, object>(); data["labels"] = Map(index.Schema().EntityTokenIds, id => anonymizer.Label(tokenLookup.LabelGetName(id), id)); data["properties"] = Map(index.Schema().PropertyIds, id => anonymizer.PropertyKey(tokenLookup.PropertyKeyGetName(id), id)); Org.Neo4j.Register.Register_DoubleLongRegister register = Registers.newDoubleLongRegister(); schemaRead.IndexUpdatesAndSize(index, register); data["totalSize"] = register.ReadSecond(); data["updatesSinceEstimation"] = register.ReadFirst(); schemaRead.IndexSample(index, register); data["estimatedUniqueSize"] = register.ReadFirst(); indexes.Add(data); } return(indexes); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSampleUniqueIndex() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldSampleUniqueIndex() { GraphDatabaseService db = null; long deletedNodes = 0; try { // Given db = (new TestGraphDatabaseFactory()).newEmbeddedDatabase(TestDirectory.storeDir()); using (Transaction tx = Db.beginTx()) { Db.schema().constraintFor(_label).assertPropertyIsUnique(_property).create(); tx.Success(); } using (Transaction tx = Db.beginTx()) { for (int i = 0; i < _nodes; i++) { Db.createNode(_label).setProperty(_property, "" + i); tx.Success(); } } using (Transaction tx = Db.beginTx()) { for (int i = 0; i < _nodes; i++) { if (i % 10 == 0) { deletedNodes++; Db.findNode(_label, _property, "" + i).delete(); tx.Success(); } } } } finally { if (db != null) { Db.shutdown(); } } // When TriggerIndexResamplingOnNextStartup(); // Then Register_DoubleLongRegister indexSampleRegister = FetchIndexSamplingValues(db); assertEquals(_nodes - deletedNodes, indexSampleRegister.ReadFirst()); assertEquals(_nodes - deletedNodes, indexSampleRegister.ReadSecond()); Register_DoubleLongRegister indexSizeRegister = FetchIndexSizeValues(db); assertEquals(0, indexSizeRegister.ReadFirst()); assertEquals(_nodes - deletedNodes, indexSizeRegister.ReadSecond()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test @Resources.Life(STARTED) public void shouldNotEndUpInBrokenStateAfterRotationFailure() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotEndUpInBrokenStateAfterRotationFailure() { // GIVEN FakeClock clock = Clocks.fakeClock(); CallTrackingClock callTrackingClock = new CallTrackingClock(clock); CountsTracker tracker = ResourceManager.managed(NewTracker(callTrackingClock, EmptyVersionContextSupplier.EMPTY)); int labelId = 1; using (Org.Neo4j.Kernel.Impl.Api.CountsAccessor_Updater tx = tracker.Apply(2).get()) { tx.IncrementNodeCount(labelId, 1); // now at 1 } // WHEN System.Predicate <Thread> arrived = thread => stackTraceContains(thread, all(classNameContains("Rotation"), methodIs("rotate"))); Future <object> rotation = Threading.executeAndAwait(t => t.rotate(4), tracker, arrived, 1, SECONDS); using (Org.Neo4j.Kernel.Impl.Api.CountsAccessor_Updater tx = tracker.Apply(3).get()) { tx.IncrementNodeCount(labelId, 1); // now at 2 } while (callTrackingClock.CallsToNanos() == 0) { Thread.Sleep(10); } clock.Forward(Config.defaults().get(GraphDatabaseSettings.counts_store_rotation_timeout).toMillis() * 2, MILLISECONDS); try { rotation.get(); fail("Should've failed rotation due to timeout"); } catch (ExecutionException e) { // good assertTrue(e.InnerException is RotationTimeoutException); } // THEN Org.Neo4j.Register.Register_DoubleLongRegister register = Registers.newDoubleLongRegister(); tracker.Get(CountsKeyFactory.nodeKey(labelId), register); assertEquals(2, register.ReadSecond()); // and WHEN later attempting rotation again using (Org.Neo4j.Kernel.Impl.Api.CountsAccessor_Updater tx = tracker.Apply(4).get()) { tx.IncrementNodeCount(labelId, 1); // now at 3 } tracker.Rotate(4); // THEN tracker.Get(CountsKeyFactory.nodeKey(labelId), register); assertEquals(3, register.ReadSecond()); }
/// <summary> /// For each index, await a resampling event unless it has zero pending updates. /// </summary> /// <param name="schemaRead"> backing schema read </param> /// <param name="timeout"> timeout in seconds. If this limit is passed, a TimeoutException is thrown. </param> /// <exception cref="TimeoutException"> if all indexes are not resampled within the timeout. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static void awaitResampling(org.neo4j.internal.kernel.api.SchemaRead schemaRead, long timeout) throws java.util.concurrent.TimeoutException public static void AwaitResampling(SchemaRead schemaRead, long timeout) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.Iterator<org.neo4j.internal.kernel.api.IndexReference> indexes = schemaRead.indexesGetAll(); IEnumerator <IndexReference> indexes = schemaRead.IndexesGetAll(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.register.Register_DoubleLongRegister register = org.neo4j.register.Registers.newDoubleLongRegister(); Org.Neo4j.Register.Register_DoubleLongRegister register = Registers.newDoubleLongRegister(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final long t0 = System.currentTimeMillis(); long t0 = DateTimeHelper.CurrentUnixTimeMillis(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final long timeoutMillis = 1000 * timeout; long timeoutMillis = 1000 * timeout; while (indexes.MoveNext()) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.internal.kernel.api.IndexReference index = indexes.Current; IndexReference index = indexes.Current; try { long readUpdates = readUpdates(index, schemaRead, register); long updateCount = readUpdates; bool hasTimedOut = false; while (updateCount > 0 && updateCount <= readUpdates && !hasTimedOut) { Thread.Sleep(10); hasTimedOut = DateTimeHelper.CurrentUnixTimeMillis() - t0 >= timeoutMillis; updateCount = Math.Max(updateCount, readUpdates); readUpdates = readUpdates(index, schemaRead, register); } if (hasTimedOut) { throw new TimeoutException(string.Format("Indexes were not resampled within {0} {1}", timeout, TimeUnit.SECONDS)); } } catch (InterruptedException e) { Thread.CurrentThread.Interrupt(); throw new Exception(e); } catch (IndexNotFoundKernelException e) { throw new ConcurrentModificationException("Index was dropped while awaiting resampling", e); } } }
public override Org.Neo4j.Register.Register_DoubleLongRegister IndexSample(long indexId, Org.Neo4j.Register.Register_DoubleLongRegister output) { return(_neoStoreIndexStoreView.indexSample(indexId, output)); }
public abstract Org.Neo4j.Register.Register_DoubleLongRegister IndexUpdatesAndSize(IndexReference index, Org.Neo4j.Register.Register_DoubleLongRegister target);
public override Org.Neo4j.Register.Register_DoubleLongRegister RelationshipCount(int startLabelId, int typeId, int endLabelId, Org.Neo4j.Register.Register_DoubleLongRegister target) { return(Get(relationshipKey(startLabelId, typeId, endLabelId), target)); }
private void MockLabelNodeCount(CountsTracker countStore, int labelId) { Org.Neo4j.Register.Register_DoubleLongRegister register = Registers.newDoubleLongRegister(labelId, labelId); when(countStore.NodeCount(eq(labelId), any(typeof(Org.Neo4j.Register.Register_DoubleLongRegister)))).thenReturn(register); }
public abstract Org.Neo4j.Register.Register_DoubleLongRegister IndexSample(IndexReference index, Org.Neo4j.Register.Register_DoubleLongRegister target);
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static long readUpdates(org.neo4j.internal.kernel.api.IndexReference index, org.neo4j.internal.kernel.api.SchemaRead schemaRead, org.neo4j.register.Register_DoubleLongRegister register) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException private static long ReadUpdates(IndexReference index, SchemaRead schemaRead, Org.Neo4j.Register.Register_DoubleLongRegister register) { schemaRead.IndexUpdatesAndSize(index, register); return(register.ReadFirst()); }
private static void AssertDoubleLongEquals(int expectedFirst, int expectedSecond, Register_DoubleLongRegister actualValues) { string msg = string.Format("Expected ({0:D},{1:D}) but was ({2:D},{3:D})", expectedFirst, expectedSecond, actualValues.ReadFirst(), actualValues.ReadSecond()); assertTrue(msg, actualValues.HasValues(expectedFirst, expectedSecond)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSampleNotUniqueIndex() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldSampleNotUniqueIndex() { GraphDatabaseService db = null; long deletedNodes = 0; try { // Given db = (new TestGraphDatabaseFactory()).newEmbeddedDatabase(TestDirectory.storeDir()); IndexDefinition indexDefinition; using (Transaction tx = Db.beginTx()) { indexDefinition = Db.schema().indexFor(_label).on(_property).create(); tx.Success(); } using (Transaction tx = Db.beginTx()) { Db.schema().awaitIndexOnline(indexDefinition, 10, TimeUnit.SECONDS); tx.Success(); } using (Transaction tx = Db.beginTx()) { for (int i = 0; i < _nodes; i++) { Db.createNode(_label).setProperty(_property, _names[i % _names.Length]); tx.Success(); } } using (Transaction tx = Db.beginTx()) { for (int i = 0; i < (_nodes / 10); i++) { using (ResourceIterator <Node> nodes = Db.findNodes(_label, _property, _names[i % _names.Length])) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: nodes.next().delete(); } deletedNodes++; tx.Success(); } } } finally { if (db != null) { Db.shutdown(); } } // When TriggerIndexResamplingOnNextStartup(); // Then // lucene will consider also the delete nodes, native won't Register_DoubleLongRegister register = FetchIndexSamplingValues(db); assertEquals(_names.Length, register.ReadFirst()); assertThat(register.ReadSecond(), allOf(greaterThanOrEqualTo(nodes - deletedNodes), lessThanOrEqualTo(nodes))); // but regardless, the deleted nodes should not be considered in the index size value Register_DoubleLongRegister indexSizeRegister = FetchIndexSizeValues(db); assertEquals(0, indexSizeRegister.ReadFirst()); assertEquals(nodes - deletedNodes, indexSizeRegister.ReadSecond()); }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected: //ORIGINAL LINE: public org.neo4j.register.Register_DoubleLongRegister nodeCount(int labelId, final org.neo4j.register.Register_DoubleLongRegister target) public override Org.Neo4j.Register.Register_DoubleLongRegister NodeCount(int labelId, Org.Neo4j.Register.Register_DoubleLongRegister target) { return(Get(nodeKey(labelId), target)); }
public override Org.Neo4j.Register.Register_DoubleLongRegister IndexUpdatesAndSize(long indexId, Org.Neo4j.Register.Register_DoubleLongRegister target) { return(Get(indexStatisticsKey(indexId), target)); }
private void AssertEqualRegisters(string message, Register_DoubleLongRegister expected, Register_DoubleLongRegister actual) { assertEquals(message + " (first part of register)", expected.ReadFirst(), actual.ReadFirst()); assertEquals(message + " (second part of register)", expected.ReadSecond(), actual.ReadSecond()); }
public void visitIndexSample(long indexId, long unique, long size) { Org.Neo4j.Register.Register_DoubleLongRegister output = _tracker.indexSample(indexId, newDoubleLongRegister()); assertEquals("Should be able to read visited state.", output.ReadFirst(), unique); assertEquals("Should be able to read visited state.", output.ReadSecond(), size); }
public void visitIndexStatistics(long indexId, long updates, long size) { Org.Neo4j.Register.Register_DoubleLongRegister output = _tracker.indexUpdatesAndSize(indexId, newDoubleLongRegister()); assertEquals("Should be able to read visited state.", output.ReadFirst(), updates); assertEquals("Should be able to read visited state.", output.ReadSecond(), size); }
public override Org.Neo4j.Register.Register_DoubleLongRegister IndexSample(long indexId, Org.Neo4j.Register.Register_DoubleLongRegister target) { return(Get(indexSampleKey(indexId), target)); }
public override Org.Neo4j.Register.Register_DoubleLongRegister IndexSample(SchemaDescriptor descriptor, Org.Neo4j.Register.Register_DoubleLongRegister target) { throw new System.NotSupportedException("Not implemented yet"); }
public virtual Org.Neo4j.Register.Register_DoubleLongRegister Get(CountsKey key, Org.Neo4j.Register.Register_DoubleLongRegister target) { try { return(Lookup(key, new ValueRegister(target))); } catch (IOException e) { throw new UnderlyingStorageException(e); } }