public override AllEntriesLabelScanReader AllNodeLabelRanges()
{
System.Func <int, RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> > seekProvider = labelId =>
{
try
{
return(_index.seek((new LabelScanKey()).Set(labelId, 0), (new LabelScanKey()).Set(labelId, long.MaxValue)));
}
catch (IOException e)
{
throw new Exception(e);
}
};
int highestLabelId = -1;
try
{
using (RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor = _index.seek((new LabelScanKey()).Set(int.MaxValue, long.MaxValue), (new LabelScanKey()).Set(0, -1)))
{
if (cursor.Next())
{
highestLabelId = cursor.get().key().labelId;
}
}
}
catch (IOException e)
{
throw new Exception(e);
}
return(new NativeAllEntriesLabelScanReader(seekProvider, highestLabelId));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCloseUnexhaustedCursorsOnReaderClose() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldCloseUnexhaustedCursorsOnReaderClose()
{
// GIVEN
GBPTree <LabelScanKey, LabelScanValue> index = mock(typeof(GBPTree));
RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor1 = mock(typeof(RawCursor));
when(cursor1.Next()).thenReturn(false);
RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor2 = mock(typeof(RawCursor));
when(cursor2.Next()).thenReturn(false);
when(index.Seek(any(typeof(LabelScanKey)), any(typeof(LabelScanKey)))).thenReturn(cursor1, cursor2);
// WHEN
using (NativeLabelScanReader reader = new NativeLabelScanReader(index))
{
// first check test invariants
reader.NodesWithLabel(LABEL_ID);
reader.NodesWithLabel(LABEL_ID);
verify(cursor1, never()).close();
verify(cursor2, never()).close();
}
// THEN
verify(cursor1, times(1)).close();
verify(cursor2, times(1)).close();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static void assertHit(org.neo4j.cursor.RawCursor<Hit<org.apache.commons.lang3.mutable.MutableLong,org.apache.commons.lang3.mutable.MutableLong>,java.io.IOException> cursor, System.Nullable<long> expectedKey) throws java.io.IOException
private static void AssertHit( RawCursor<Hit<MutableLong, MutableLong>, IOException> cursor, long? expectedKey )
{
assertTrue( "Had no next when expecting key " + expectedKey, cursor.Next() );
Hit<MutableLong, MutableLong> hit = cursor.get();
assertEquals( expectedKey.Value, hit.Key().longValue() );
assertEquals( Value( expectedKey.Value ), hit.Value().longValue() );
}
private void StartSeekForRange(Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient client, IndexQuery.GeometryRangePredicate rangePredicate, IndexQuery[] query)
{
try
{
BridgingIndexProgressor multiProgressor = new BridgingIndexProgressor(client, descriptor.schema().PropertyIds);
client.Initialize(descriptor, multiProgressor, query, IndexOrder.NONE, false);
SpaceFillingCurve curve = _spatial.SpaceFillingCurve;
double[] from = rangePredicate.From() == null ? null : rangePredicate.From().coordinate();
double[] to = rangePredicate.To() == null ? null : rangePredicate.To().coordinate();
IList <SpaceFillingCurve.LongRange> ranges = curve.GetTilesIntersectingEnvelope(from, to, _configuration);
foreach (SpaceFillingCurve.LongRange range in ranges)
{
SpatialIndexKey treeKeyFrom = layout.newKey();
SpatialIndexKey treeKeyTo = layout.newKey();
InitializeKeys(treeKeyFrom, treeKeyTo);
treeKeyFrom.FromDerivedValue(long.MinValue, range.Min);
treeKeyTo.FromDerivedValue(long.MaxValue, range.Max + 1);
RawCursor <Hit <SpatialIndexKey, VALUE>, IOException> seeker = makeIndexSeeker(treeKeyFrom, treeKeyTo, IndexOrder.NONE);
IndexProgressor hitProgressor = new NativeHitIndexProgressor <>(seeker, client, openSeekers);
multiProgressor.Initialize(descriptor, hitProgressor, query, IndexOrder.NONE, false);
}
}
catch (System.ArgumentException)
{
// Invalid query ranges will cause this state (eg. min>max)
client.Initialize(descriptor, IndexProgressor.EMPTY, query, IndexOrder.NONE, false);
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
// Timeout because test verify no infinite loop
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(timeout = 10_000L) public void shouldHandleDescendingWithEmptyRange() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldHandleDescendingWithEmptyRange()
{
long[] seeds = new long[] { 0, 1, 4 };
using (GBPTree <KEY, VALUE> index = CreateIndex())
{
// Write
using (Writer <KEY, VALUE> writer = CreateWriter(index))
{
foreach (long seed in seeds)
{
KEY key = _layout.key(seed);
VALUE value = _layout.value(0);
writer.Put(key, value);
}
}
KEY from = _layout.key(3);
KEY to = _layout.key(1);
using (RawCursor <Hit <KEY, VALUE>, IOException> seek = index.Seek(from, to))
{
assertFalse(seek.Next());
}
index.Checkpoint(Org.Neo4j.Io.pagecache.IOLimiter_Fields.Unlimited);
}
}
public override long CountIndexedNodes(long nodeId, int[] propertyKeyIds, params Value[] propertyValues)
{
KEY treeKeyFrom = Layout.newKey();
KEY treeKeyTo = Layout.newKey();
treeKeyFrom.initialize(nodeId);
treeKeyTo.initialize(nodeId);
for (int i = 0; i < propertyValues.Length; i++)
{
treeKeyFrom.initFromValue(i, propertyValues[i], NEUTRAL);
treeKeyTo.initFromValue(i, propertyValues[i], NEUTRAL);
}
try
{
using (RawCursor <Hit <KEY, VALUE>, IOException> seeker = Tree.seek(treeKeyFrom, treeKeyTo))
{
long count = 0;
while (seeker.Next())
{
if (seeker.get().key().EntityId == nodeId)
{
count++;
}
}
return(count);
}
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldPerformSuccessfulStoreCopyProcess() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldPerformSuccessfulStoreCopyProcess()
{
// given
StoreStreamingProcess process = new StoreStreamingProcess(_protocol, _checkPointerSupplier, _mutex, _resourceStream);
// mocked behaviour
ImmediateEventExecutor eventExecutor = ImmediateEventExecutor.INSTANCE;
Promise <Void> completionPromise = eventExecutor.newPromise();
long lastCheckpointedTxId = 1000L;
RawCursor <StoreResource, IOException> resources = rawCursorOf();
when(_checkPointer.tryCheckPoint(any())).thenReturn(lastCheckpointedTxId);
when(_checkPointer.lastCheckPointedTransactionId()).thenReturn(lastCheckpointedTxId);
when(_protocol.end(_ctx, SUCCESS)).thenReturn(completionPromise);
when(_resourceStream.create()).thenReturn(resources);
// when
process.Perform(_ctx);
// then
InOrder inOrder = Mockito.inOrder(_protocol, _checkPointer);
inOrder.verify(_checkPointer).tryCheckPoint(any());
inOrder.verify(_protocol).end(_ctx, SUCCESS);
inOrder.verifyNoMoreInteractions();
assertEquals(1, @lock.ReadLockCount);
// when
completionPromise.Success = null;
// then
assertEquals(0, @lock.ReadLockCount);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: void perform(io.netty.channel.ChannelHandlerContext ctx) throws java.io.IOException
internal virtual void Perform(ChannelHandlerContext ctx)
{
CheckPointer checkPointer = _checkPointerSupplier.get();
Resource checkPointLock = _mutex.storeCopy(() => checkPointer.TryCheckPoint(new SimpleTriggerInfo("Store copy")));
Future <Void> completion = null;
try
{
using (RawCursor <StoreResource, IOException> resources = _resourceStreamFactory.create())
{
while (resources.Next())
{
StoreResource resource = resources.get();
_protocol.stream(ctx, resource);
}
completion = _protocol.end(ctx, SUCCESS);
}
}
finally
{
if (completion != null)
{
completion.addListener(f => checkPointLock.close());
}
else
{
checkPointLock.Close();
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void closeSeeker() throws java.io.IOException
private void CloseSeeker()
{
if (_seeker != null)
{
_seeker.close();
_seeker = null;
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHandleRemoveEntireTree() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldHandleRemoveEntireTree()
{
// given
using (GBPTree <KEY, VALUE> index = CreateIndex())
{
int numberOfNodes = 200_000;
using (Writer <KEY, VALUE> writer = CreateWriter(index))
{
for (int i = 0; i < numberOfNodes; i++)
{
writer.Put(Key(i), Value(i));
}
}
// when
BitArray removed = new BitArray();
using (Writer <KEY, VALUE> writer = CreateWriter(index))
{
for (int i = 0; i < numberOfNodes - numberOfNodes / 10; i++)
{
int candidate;
do
{
candidate = Random.Next(max(1, Random.Next(numberOfNodes)));
} while (removed.Get(candidate));
removed.Set(candidate, true);
writer.Remove(Key(candidate));
}
}
int next = 0;
using (Writer <KEY, VALUE> writer = CreateWriter(index))
{
for (int i = 0; i < numberOfNodes / 10; i++)
{
next = removed.nextClearBit(next);
removed.Set(next, true);
writer.Remove(Key(next));
}
}
// then
using (RawCursor <Hit <KEY, VALUE>, IOException> seek = index.Seek(Key(0), Key(numberOfNodes)))
{
assertFalse(seek.Next());
}
// and finally
index.ConsistencyCheck();
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: org.neo4j.cursor.RawCursor<org.neo4j.index.internal.gbptree.Hit<KEY,VALUE>,java.io.IOException> makeIndexSeeker(KEY treeKeyFrom, KEY treeKeyTo, org.neo4j.internal.kernel.api.IndexOrder indexOrder) throws java.io.IOException
internal virtual RawCursor <Hit <KEY, VALUE>, IOException> MakeIndexSeeker(KEY treeKeyFrom, KEY treeKeyTo, IndexOrder indexOrder)
{
if (indexOrder == IndexOrder.DESCENDING)
{
KEY tmpKey = treeKeyFrom;
treeKeyFrom = treeKeyTo;
treeKeyTo = tmpKey;
}
RawCursor <Hit <KEY, VALUE>, IOException> seeker = Tree.seek(treeKeyFrom, treeKeyTo);
OpenSeekers.Add(seeker);
return(seeker);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void verifyUniqueSeek(org.neo4j.cursor.RawCursor<org.neo4j.index.internal.gbptree.Hit<KEY,VALUE>,java.io.IOException> seek) throws java.io.IOException, org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException
private void VerifyUniqueSeek(RawCursor <Hit <KEY, VALUE>, IOException> seek)
{
if (seek != null)
{
if (seek.Next())
{
long firstEntityId = seek.get().key().EntityId;
if (seek.Next())
{
long secondEntityId = seek.get().key().EntityId;
throw new IndexEntryConflictException(firstEntityId, secondEntityId, seek.get().key().asValues());
}
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static <E extends Exception> int count(org.neo4j.cursor.RawCursor<?,E> cursor) throws E
public static int Count <E, T1>(RawCursor <T1> cursor) where E : Exception
{
try
{
int count = 0;
while (cursor.Next())
{
count++;
}
return(count);
}
finally
{
cursor.Close();
}
}
public override IndexSample Result()
{
KEY lowest = _layout.newKey();
lowest.initialize(long.MinValue);
lowest.initValuesAsLowest();
KEY highest = _layout.newKey();
highest.initialize(long.MaxValue);
highest.initValuesAsHighest();
KEY prev = _layout.newKey();
try
{
using (RawCursor <Hit <KEY, VALUE>, IOException> seek = _gbpTree.seek(lowest, highest))
{
long sampledValues = 0;
long uniqueValues = 0;
// Get the first one so that prev gets initialized
if (seek.Next())
{
prev = _layout.copyKey(seek.get().key(), prev);
sampledValues++;
uniqueValues++;
// Then do the rest
while (seek.Next())
{
Hit <KEY, VALUE> hit = seek.get();
if (_layout.compareValue(prev, hit.Key()) != 0)
{
uniqueValues++;
_layout.copyKey(hit.Key(), prev);
}
// else this is a duplicate of the previous one
sampledValues++;
}
}
return(new IndexSample(sampledValues, uniqueValues, sampledValues));
}
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
/* Randomized tests */
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSplitCorrectly() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSplitCorrectly()
{
// GIVEN
using (GBPTree <KEY, VALUE> index = index())
{
// WHEN
int count = 1_000;
IList <KEY> seen = new List <KEY>(count);
using (Writer <KEY, VALUE> writer = index.Writer())
{
for (int i = 0; i < count; i++)
{
KEY key;
do
{
key = key(_random.Next(100_000));
} while (ListContains(seen, key));
VALUE value = value(i);
writer.Put(key, value);
seen.Add(key);
}
}
// THEN
using (RawCursor <Hit <KEY, VALUE>, IOException> cursor = index.Seek(Key(0), Key(long.MaxValue)))
{
long prev = -1;
while (cursor.Next())
{
KEY hit = cursor.get().key();
long hitSeed = _layout.keySeed(hit);
if (hitSeed < prev)
{
fail(hit + " smaller than prev " + prev);
}
prev = hitSeed;
assertTrue(RemoveFromList(seen, hit));
}
if (seen.Count > 0)
{
fail("expected hits " + seen);
}
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void shouldWriteAndReadEntriesOfRandomSizes(int minKeySize, int maxKeySize, int minValueSize, int maxValueSize) throws java.io.IOException
private void ShouldWriteAndReadEntriesOfRandomSizes(int minKeySize, int maxKeySize, int minValueSize, int maxValueSize)
{
// given
using (GBPTree <RawBytes, RawBytes> tree = CreateIndex(Layout()))
{
// when
ISet <string> generatedStrings = new HashSet <string>();
IList <Pair <RawBytes, RawBytes> > entries = new List <Pair <RawBytes, RawBytes> >();
using (Writer <RawBytes, RawBytes> writer = tree.Writer())
{
for (int i = 0; i < 1_000; i++)
{
// value, based on i
RawBytes value = new RawBytes();
value.Bytes = new sbyte[Random.Next(minValueSize, maxValueSize)];
Random.NextBytes(value.Bytes);
// key, randomly generated
string @string;
do
{
@string = Random.nextAlphaNumericString(minKeySize, maxKeySize);
} while (!generatedStrings.Add(@string));
RawBytes key = new RawBytes();
key.Bytes = UTF8.encode(@string);
entries.Add(Pair.of(key, value));
// write
writer.Put(key, value);
}
}
// then
foreach (Pair <RawBytes, RawBytes> entry in entries)
{
using (RawCursor <Hit <RawBytes, RawBytes>, IOException> seek = tree.Seek(entry.First(), entry.First()))
{
assertTrue(seek.Next());
assertArrayEquals(entry.First().Bytes, seek.get().key().bytes);
assertArrayEquals(entry.Other().Bytes, seek.get().value().bytes);
assertFalse(seek.Next());
}
}
}
}
internal virtual void StartSeekForInitializedRange(Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient client, KEY treeKeyFrom, KEY treeKeyTo, IndexQuery[] query, IndexOrder indexOrder, bool needFilter, bool needsValues)
{
if (IsEmptyRange(treeKeyFrom, treeKeyTo))
{
client.Initialize(Descriptor, IndexProgressor.EMPTY, query, indexOrder, needsValues);
return;
}
try
{
RawCursor <Hit <KEY, VALUE>, IOException> seeker = MakeIndexSeeker(treeKeyFrom, treeKeyTo, indexOrder);
IndexProgressor hitProgressor = GetIndexProgressor(seeker, client, needFilter, query);
client.Initialize(Descriptor, hitProgressor, query, indexOrder, needsValues);
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") @Test public void shouldFindMultipleNodesInEachRange() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldFindMultipleNodesInEachRange()
{
// GIVEN
GBPTree <LabelScanKey, LabelScanValue> index = mock(typeof(GBPTree));
RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor = mock(typeof(RawCursor));
when(cursor.Next()).thenReturn(true, true, true, false);
when(cursor.get()).thenReturn(Hit(0, 0b1000_1000__1100_0010L), Hit(1, 0b0000_0010__0000_1000L), Hit(3, 0b0010_0000__1010_0001L), null);
when(index.Seek(any(typeof(LabelScanKey)), any(typeof(LabelScanKey)))).thenReturn(cursor);
using (NativeLabelScanReader reader = new NativeLabelScanReader(index))
{
// WHEN
LongIterator iterator = reader.NodesWithLabel(LABEL_ID);
// THEN
assertArrayEquals(new long[] { 1, 6, 7, 11, 15, 64 + 3, 64 + 9, 192 + 0, 192 + 5, 192 + 7, 192 + 13 }, asArray(iterator));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldStartFromGivenId() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldStartFromGivenId()
{
// given
GBPTree <LabelScanKey, LabelScanValue> index = mock(typeof(GBPTree));
RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor = mock(typeof(RawCursor));
when(cursor.Next()).thenReturn(true, true, false);
when(cursor.get()).thenReturn(Hit(1, 0b0001_1000__0101_1110L), Hit(3, 0b0010_0000__1010_0001L), null);
when(index.Seek(any(typeof(LabelScanKey)), any(typeof(LabelScanKey)))).thenReturn(cursor);
// when
long fromId = LabelScanValue.RangeSize + 3;
using (NativeLabelScanReader reader = new NativeLabelScanReader(index), PrimitiveLongResourceIterator iterator = reader.NodesWithAnyOfLabels(fromId, LABEL_ID))
{
// then
assertArrayEquals(new long[] { 64 + 4, 64 + 6, 64 + 11, 64 + 12, 192 + 0, 192 + 5, 192 + 7, 192 + 13 }, asArray(iterator));
}
}
private IList <PrimitiveLongResourceIterator> IteratorsForLabels(long fromId, int[] labelIds)
{
IList <PrimitiveLongResourceIterator> iterators = new List <PrimitiveLongResourceIterator>();
try
{
foreach (int labelId in labelIds)
{
RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor = SeekerForLabel(fromId, labelId);
_openCursors.Add(cursor);
iterators.Add(new LabelScanValueIterator(cursor, _openCursors, fromId));
}
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
return(iterators);
}
public override void DistinctValues(Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient client, NodePropertyAccessor propertyAccessor, bool needsValues)
{
KEY lowest = Layout.newKey();
lowest.initialize(long.MinValue);
lowest.initValuesAsLowest();
KEY highest = Layout.newKey();
highest.initialize(long.MaxValue);
highest.initValuesAsHighest();
try
{
RawCursor <Hit <KEY, VALUE>, IOException> seeker = Tree.seek(lowest, highest);
client.Initialize(Descriptor, new NativeDistinctValuesProgressor <>(seeker, client, OpenSeekers, Layout, Layout.compareValue), new IndexQuery[0], IndexOrder.NONE, needsValues);
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
public override IEnumerator <long> Iterator()
{
KEY from = _layout.newKey();
from.initialize(long.MinValue);
from.initValuesAsLowest();
KEY to = _layout.newKey();
to.initialize(long.MaxValue);
to.initValuesAsHighest();
try
{
CloseSeeker();
_seeker = _tree.seek(from, to);
return(new PrefetchingIteratorAnonymousInnerClass(this));
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
internal override void StartSeekForInitializedRange(Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient client, SpatialIndexKey treeKeyFrom, SpatialIndexKey treeKeyTo, IndexQuery[] query, IndexOrder indexOrder, bool needFilter, bool needsValues)
{
// Spatial does not support providing values
Debug.Assert(!needsValues);
if (layout.compare(treeKeyFrom, treeKeyTo) > 0)
{
client.Initialize(descriptor, IndexProgressor.EMPTY, query, IndexOrder.NONE, false);
return;
}
try
{
RawCursor <Hit <SpatialIndexKey, VALUE>, IOException> seeker = makeIndexSeeker(treeKeyFrom, treeKeyTo, indexOrder);
IndexProgressor hitProgressor = new NativeHitIndexProgressor <>(seeker, client, openSeekers);
client.Initialize(descriptor, hitProgressor, query, IndexOrder.NONE, false);
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRecoverFromCrashBeforeFirstCheckpoint() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldRecoverFromCrashBeforeFirstCheckpoint()
{
// GIVEN
// a tree with only small amount of data that has not yet seen checkpoint from outside
KEY key = key(1L);
VALUE value = value(10L);
File file = _directory.file("index");
{
using (PageCache pageCache = CreatePageCache(), GBPTree <KEY, VALUE> index = CreateIndex(pageCache, file), Writer <KEY, VALUE> writer = index.Writer())
{
writer.Put(key, value);
pageCache.FlushAndForce();
// No checkpoint
}
}
// WHEN
using (PageCache pageCache = CreatePageCache(), GBPTree <KEY, VALUE> index = CreateIndex(pageCache, file))
{
using (Writer <KEY, VALUE> writer = index.Writer())
{
writer.Put(key, value);
}
// THEN
// we should end up with a consistent index
index.ConsistencyCheck();
// ... containing all the stuff load says
using (RawCursor <Hit <KEY, VALUE>, IOException> cursor = index.Seek(key(long.MinValue), key(long.MaxValue)))
{
assertTrue(cursor.Next());
Hit <KEY, VALUE> hit = cursor.get();
AssertEqualsKey(key, hit.Key());
AssertEqualsValue(value, hit.Value());
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCloseExhaustedCursors() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldCloseExhaustedCursors()
{
// GIVEN
RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor = mock(typeof(RawCursor));
when(cursor.Next()).thenReturn(false);
ICollection <RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> > toRemoveFrom = new HashSet <RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> >();
LabelScanValueIndexProgressor iterator = new LabelScanValueIndexProgressor(cursor, toRemoveFrom, mock(typeof(Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeLabelClient)));
verify(cursor, never()).close();
// WHEN
Exhaust(iterator);
verify(cursor, times(1)).close();
// retrying to get more items from the first one should not close it again
iterator.Next();
verify(cursor, times(1)).close();
// and set should be empty
assertTrue(toRemoveFrom.Count == 0);
}
public override IEnumerator <NodeLabelRange> Iterator()
{
try
{
long lowestRange = long.MaxValue;
CloseCursors();
for (int labelId = 0; labelId <= _highestLabelId; labelId++)
{
RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor = _seekProvider.apply(labelId);
// Bootstrap the cursor, which also provides a great opportunity to exclude if empty
if (cursor.Next())
{
lowestRange = min(lowestRange, cursor.get().key().idRange);
_cursors.Add(cursor);
}
}
return(new NodeLabelRangeIterator(this, lowestRange));
}
catch (IOException e)
{
throw new Exception(e);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSupportMultipleOpenCursorsConcurrently() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSupportMultipleOpenCursorsConcurrently()
{
// GIVEN
GBPTree <LabelScanKey, LabelScanValue> index = mock(typeof(GBPTree));
RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor1 = mock(typeof(RawCursor));
when(cursor1.Next()).thenReturn(false);
RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor2 = mock(typeof(RawCursor));
when(cursor2.Next()).thenReturn(false);
when(index.Seek(any(typeof(LabelScanKey)), any(typeof(LabelScanKey)))).thenReturn(cursor1, cursor2);
// WHEN
using (NativeLabelScanReader reader = new NativeLabelScanReader(index))
{
// first check test invariants
verify(cursor1, never()).close();
verify(cursor2, never()).close();
LongIterator first = reader.NodesWithLabel(LABEL_ID);
LongIterator second = reader.NodesWithLabel(LABEL_ID);
// getting the second iterator should not have closed the first one
verify(cursor1, never()).close();
verify(cursor2, never()).close();
// exhausting the first one should have closed only the first one
Exhaust(first);
verify(cursor1, times(1)).close();
verify(cursor2, never()).close();
// exhausting the second one should close it
Exhaust(second);
verify(cursor1, times(1)).close();
verify(cursor2, times(1)).close();
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldStreamResources() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldStreamResources()
{
// given
StoreFileStreamingProtocol protocol = new StoreFileStreamingProtocol();
ChannelHandlerContext ctx = mock(typeof(ChannelHandlerContext));
Fs.mkdir(new File("dirA"));
Fs.mkdir(new File("dirB"));
string[] files = new string[] { "dirA/one", "dirA/two", "dirB/one", "dirB/two", "one", "two", "three" };
IList <StoreResource> resourceList = new List <StoreResource>();
foreach (string file in files)
{
resourceList.Add(CreateResource(new File(file), ThreadLocalRandom.current().Next(1, 4096)));
}
RawCursor <StoreResource, IOException> resources = rawCursorOf(resourceList);
// when
while (resources.Next())
{
protocol.Stream(ctx, resources.get());
}
// then
InOrder inOrder = Mockito.inOrder(ctx);
foreach (StoreResource resource in resourceList)
{
inOrder.verify(ctx).write(ResponseMessageType.FILE);
inOrder.verify(ctx).write(new FileHeader(resource.Path(), resource.RecordSize()));
inOrder.verify(ctx).write(new FileSender(resource));
}
verifyNoMoreInteractions(ctx);
}
public override void DistinctValues(Org.Neo4j.Storageengine.Api.schema.IndexProgressor_NodeValueClient client, NodePropertyAccessor propertyAccessor, bool needsValues)
{
// This is basically a version of the basic implementation, but with added consulting of the PropertyAccessor
// since these are lossy spatial values.
SpatialIndexKey lowest = layout.newKey();
lowest.initialize(long.MinValue);
lowest.initValuesAsLowest();
SpatialIndexKey highest = layout.newKey();
highest.initialize(long.MaxValue);
highest.initValuesAsHighest();
try
{
RawCursor <Hit <SpatialIndexKey, VALUE>, IOException> seeker = tree.seek(lowest, highest);
IComparer <SpatialIndexKey> comparator = new PropertyLookupFallbackComparator <SpatialIndexKey>(layout, propertyAccessor, descriptor.schema().PropertyId);
NativeDistinctValuesProgressor <SpatialIndexKey, VALUE> progressor = new NativeDistinctValuesProgressorAnonymousInnerClass(this, seeker, client, openSeekers, layout, comparator, propertyAccessor);
client.Initialize(descriptor, progressor, new IndexQuery[0], IndexOrder.NONE, false);
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSeeSimpleInsertions() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSeeSimpleInsertions()
{
using (GBPTree <KEY, VALUE> index = index())
{
int count = 1000;
using (Writer <KEY, VALUE> writer = index.Writer())
{
for (int i = 0; i < count; i++)
{
writer.Put(Key(i), Value(i));
}
}
using (RawCursor <Hit <KEY, VALUE>, IOException> cursor = index.Seek(Key(0), Key(long.MaxValue)))
{
for (int i = 0; i < count; i++)
{
assertTrue(cursor.Next());
AssertEqualsKey(Key(i), cursor.get().key());
}
assertFalse(cursor.Next());
}
}
}
