//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRemoveIndexStatisticsAfterIndexIsDeleted() throws org.neo4j.internal.kernel.api.exceptions.KernelException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldRemoveIndexStatisticsAfterIndexIsDeleted()
{
// given
_indexOnlineMonitor.initialize(0);
CreateSomePersons();
IndexReference index = CreatePersonNameIndex();
AwaitIndexesOnline();
SchemaStorage storage = new SchemaStorage(NeoStores().SchemaStore);
long indexId = storage.IndexGetForSchema(( IndexDescriptor )index).Id;
// when
DropIndex(index);
// then
try
{
IndexSelectivity(index);
fail("Expected IndexNotFoundKernelException to be thrown");
}
catch (IndexNotFoundKernelException)
{
Register_DoubleLongRegister actual = Tracker.indexSample(indexId, Registers.newDoubleLongRegister());
AssertDoubleLongEquals(0L, 0L, actual);
}
// and then index size and index updates are zero on disk
Register_DoubleLongRegister actual = Tracker.indexUpdatesAndSize(indexId, Registers.newDoubleLongRegister());
AssertDoubleLongEquals(0L, 0L, actual);
}
public override void Accept(CountsVisitor visitor)
{
foreach (KeyValuePair <CountsKey, Register_DoubleLongRegister> entry in _counts.SetOfKeyValuePairs())
{
Register_DoubleLongRegister register = entry.Value;
entry.Key.accept(visitor, register.ReadFirst(), register.ReadSecond());
}
}
public virtual IList <Difference> Differences()
{
foreach (KeyValuePair <CountsKey, Register_DoubleLongRegister> entry in Counts.SetOfKeyValuePairs())
{
Register_DoubleLongRegister value = entry.Value;
DifferencesConflict.Add(new Difference(entry.Key, value.ReadFirst(), value.ReadSecond(), 0, 0));
}
Counts.Clear();
return(DifferencesConflict);
}
internal virtual void Verify(CountsKey key, long actualFirst, long actualSecond)
{
Register_DoubleLongRegister expected = Counts.Remove(key);
if (expected == null)
{
if (actualFirst != 0 || actualSecond != 0)
{
DifferencesConflict.Add(new Difference(key, 0, 0, actualFirst, actualSecond));
}
}
else
{
long expectedFirst = expected.ReadFirst();
long expectedSecond = expected.ReadSecond();
if (expectedFirst != actualFirst || expectedSecond != actualSecond)
{
DifferencesConflict.Add(new Difference(key, expectedFirst, expectedSecond, actualFirst, actualSecond));
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static void checkIndexCounts(Store store, org.neo4j.kernel.internal.GraphDatabaseAPI db) throws org.neo4j.internal.kernel.api.exceptions.KernelException
private static void CheckIndexCounts(Store store, GraphDatabaseAPI db)
{
InwardKernel kernel = Db.DependencyResolver.resolveDependency(typeof(InwardKernel));
using (KernelTransaction tx = kernel.BeginTransaction(@implicit, AnonymousContext.read()), Statement ignore = tx.AcquireStatement())
{
SchemaRead schemaRead = tx.SchemaRead();
IEnumerator <IndexReference> indexes = IndexReference.sortByType(GetAllIndexes(schemaRead));
Register_DoubleLongRegister register = Registers.newDoubleLongRegister();
for (int i = 0; indexes.MoveNext(); i++)
{
IndexReference reference = indexes.Current;
// wait index to be online since sometimes we need to rebuild the indexes on migration
AwaitOnline(schemaRead, reference);
AssertDoubleLongEquals(store.IndexCounts[i][0], store.IndexCounts[i][1], schemaRead.IndexUpdatesAndSize(reference, register));
AssertDoubleLongEquals(store.IndexCounts[i][2], store.IndexCounts[i][3], schemaRead.IndexSample(reference, register));
double selectivity = schemaRead.IndexUniqueValuesSelectivity(reference);
assertEquals(store.IndexSelectivity[i], selectivity, 0.0000001d);
}
}
}
private static void AssertDoubleLongEquals(long expectedFirst, long expectedSecond, Register_DoubleLongRegister register)
{
long first = register.ReadFirst();
long second = register.ReadSecond();
string msg = string.Format("Expected ({0:D},{1:D}), got ({2:D},{3:D})", expectedFirst, expectedSecond, first, second);
assertEquals(msg, expectedFirst, first);
assertEquals(msg, expectedSecond, second);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.register.Register_DoubleLongRegister indexSample(org.neo4j.internal.kernel.api.schema.SchemaDescriptor descriptor, org.neo4j.register.Register_DoubleLongRegister target) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException
public override Register_DoubleLongRegister IndexSample(SchemaDescriptor descriptor, Register_DoubleLongRegister target)
{
return(_counts.indexSample(TryGetIndexId(descriptor), target));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public long indexSize(org.neo4j.internal.kernel.api.schema.SchemaDescriptor descriptor) throws org.neo4j.internal.kernel.api.exceptions.schema.IndexNotFoundKernelException
public override long IndexSize(SchemaDescriptor descriptor)
{
Register_DoubleLongRegister result = _indexService.indexUpdatesAndSize(descriptor);
return(result.ReadSecond());
}
public override Register_DoubleLongRegister IndexSample(long indexId, Register_DoubleLongRegister output)
{
return(_counts.indexSample(indexId, output));
}
public override Register_DoubleLongRegister IndexUpdatesAndSize(long indexId, Register_DoubleLongRegister output)
{
return(_counts.indexUpdatesAndSize(indexId, output));
}
private void AssertDoubleLongEquals(long expectedUniqueValue, long expectedSampledSize, Register_DoubleLongRegister register)
{
assertEquals(expectedUniqueValue, register.ReadFirst());
assertEquals(expectedSampledSize, register.ReadSecond());
}
public override Register_DoubleLongRegister IndexUpdatesAndSize(long indexId, Register_DoubleLongRegister target)
{
Counts(indexStatisticsKey(indexId)).copyTo(target);
return(target);
}
public override Register_DoubleLongRegister IndexSample(long indexId, Register_DoubleLongRegister target)
{
Counts(indexSampleKey(indexId)).copyTo(target);
return(target);
}
public override Register_DoubleLongRegister RelationshipCount(int startLabelId, int typeId, int endLabelId, Register_DoubleLongRegister target)
{
Counts(relationshipKey(startLabelId, typeId, endLabelId)).copyTo(target);
return(target);
}
public override Register_DoubleLongRegister NodeCount(int labelId, Register_DoubleLongRegister target)
{
Counts(nodeKey(labelId)).copyTo(target);
return(target);
}
public override Register_DoubleLongRegister IndexSample(long indexId, Register_DoubleLongRegister output)
{
return(output);
}
