private void assertEntityIdHits( long[] expected, LongIterator result ) { long[] actual = PrimitiveLongCollections.asArray( result ); assertSameContent( expected, actual ); }
private long[] readNodesForLabel( LabelScanStore labelScanStore ) { try ( LabelScanReader reader = labelScanStore.newReader() ) { return PrimitiveLongCollections.asArray( reader.nodesWithLabel( labelId ) ); } }
@Test void asArray() { // GIVEN LongIterator items = PrimitiveLongCollections.iterator( 1, 2, 3 ); // WHEN long[] array = PrimitiveLongCollections.asArray( items ); // THEN assertTrue( Arrays.equals( new long[] { 1, 2, 3 }, array ) ); }
@Test public void mustReportAllFromSingleIterator() { // given long[] expected = {0L, 1L, Long.MAX_VALUE}; List<PrimitiveLongResourceIterator> iterators = Collections.singletonList( iterator( null, expected ) ); // when CompositeLabelScanValueIterator iterator = new CompositeLabelScanValueIterator( iterators, false ); // then assertArrayEquals( expected, PrimitiveLongCollections.asArray( iterator ) ); }
private static void assertRanges( AllEntriesLabelScanReader reader, Labels[] data ) { Iterator<NodeLabelRange> iterator = reader.iterator(); long highestRangeId = highestRangeId( data ); for ( long rangeId = 0; rangeId <= highestRangeId; rangeId++ ) { SortedMap<Long/*nodeId*/,List<Long>/*labelIds*/> expected = rangeOf( data, rangeId ); if ( expected != null ) { assertTrue( "Was expecting range " + expected, iterator.hasNext() ); NodeLabelRange range = iterator.next(); assertEquals( rangeId, range.id() ); for ( Map.Entry<Long,List<Long>> expectedEntry : expected.entrySet() ) { long[] labels = range.labels( expectedEntry.getKey() ); assertArrayEquals( asArray( expectedEntry.getValue().iterator() ), labels ); } } // else there was nothing in this range } assertFalse( iterator.hasNext() ); }
private void verifyReads( long[] expected ) { try ( LabelScanReader reader = store.newReader() ) { for ( int i = 0; i < LABEL_COUNT; i++ ) { long[] actualNodes = asArray( reader.nodesWithLabel( i ) ); long[] expectedNodes = nodesWithLabel( expected, i ); assertArrayEquals( expectedNodes, actualNodes ); } } }
@Test public void shouldReturnNoEntriesForExistsPredicateForEmptyIndex() throws Exception { // when IndexReader reader = accessor.newReader(); LongIterator result = query( reader, IndexQuery.exists( 0 ) ); // then long[] actual = PrimitiveLongCollections.asArray( result ); assertEquals( 0, actual.length ); }
@Test public void indexNumberRangeQuery() throws Exception { updateAndCommit( asList( add( 1, 1 ), add( 2, 2 ), add( 3, 3 ), add( 4, 4 ), add( 5, Double.NaN ) ) ); IndexReader reader = accessor.newReader(); LongIterator rangeTwoThree = reader.query( range( PROP_ID, 2, true, 3, true ) ); assertThat( PrimitiveLongCollections.asArray( rangeTwoThree ), LongArrayMatcher.of( 2, 3 ) ); LongIterator infiniteMaxRange = reader.query( range( PROP_ID, 2, true, Long.MAX_VALUE, true ) ); assertThat( PrimitiveLongCollections.asArray( infiniteMaxRange ), LongArrayMatcher.of( 2, 3, 4 ) ); LongIterator infiniteMinRange = reader.query( range( PROP_ID, Long.MIN_VALUE, true, 3, true ) ); assertThat( PrimitiveLongCollections.asArray( infiniteMinRange ), LongArrayMatcher.of( PROP_ID, 2, 3 ) ); LongIterator maxNanInterval = reader.query( range( PROP_ID, 3, true, Double.NaN, true ) ); assertThat( PrimitiveLongCollections.asArray( maxNanInterval ), LongArrayMatcher.of( 3, 4, 5 ) ); LongIterator minNanInterval = reader.query( range( PROP_ID, Double.NaN, true, 5, true ) ); assertThat( PrimitiveLongCollections.asArray( minNanInterval ), LongArrayMatcher.emptyArrayMatcher() ); LongIterator nanInterval = reader.query( range( PROP_ID, Double.NaN, true, Double.NaN, true ) ); assertThat( PrimitiveLongCollections.asArray( nanInterval ), LongArrayMatcher.of( 5 ) ); }
@Test public void mustReportAllFromNonOverlappingMultipleIterators() { // given AtomicInteger closeCounter = new AtomicInteger(); long[] firstIter = {0L, 2L, Long.MAX_VALUE}; long[] secondIter = { 1L, 3L }; long[] expected = {0L, 1L, 2L, 3L, Long.MAX_VALUE}; List<PrimitiveLongResourceIterator> iterators = asMutableList( iterator( closeCounter::incrementAndGet, firstIter ), iterator( closeCounter::incrementAndGet, secondIter ) ); // when CompositeLabelScanValueIterator iterator = new CompositeLabelScanValueIterator( iterators, false ); // then assertArrayEquals( expected, PrimitiveLongCollections.asArray( iterator ) ); // when iterator.close(); // then assertEquals( "expected close count", 2, closeCounter.get() ); }
@Test public void shouldGetRelationshipsByTypeAndDirection() { RelationshipChangesForNode changes = new RelationshipChangesForNode( RelationshipChangesForNode.DiffStrategy.ADD ); final int TYPE = 2; final int DECOY_TYPE = 666; changes.addRelationship( 1, TYPE, INCOMING ); changes.addRelationship( 2, TYPE, OUTGOING ); changes.addRelationship( 3, TYPE, OUTGOING ); changes.addRelationship( 4, TYPE, LOOP ); changes.addRelationship( 5, TYPE, LOOP ); changes.addRelationship( 6, TYPE, LOOP ); changes.addRelationship( 10, DECOY_TYPE, INCOMING ); changes.addRelationship( 11, DECOY_TYPE, OUTGOING ); changes.addRelationship( 12, DECOY_TYPE, LOOP ); LongIterator rawIncoming = changes.getRelationships( RelationshipDirection.INCOMING, TYPE ); assertThat( PrimitiveLongCollections.asArray( rawIncoming ), ids( 1 ) ); LongIterator rawOutgoing = changes.getRelationships( RelationshipDirection.OUTGOING, TYPE ); assertThat( PrimitiveLongCollections.asArray( rawOutgoing ), ids( 2, 3 ) ); LongIterator rawLoops = changes.getRelationships( RelationshipDirection.LOOP, TYPE ); assertThat( PrimitiveLongCollections.asArray( rawLoops ), ids( 4, 5, 6 ) ); }
@Test public void indexStringRangeQuery() throws Exception { updateAndCommit( asList( add( PROP_ID, "A" ), add( 2, "B" ), add( 3, "C" ), add( 4, "" ) ) ); IndexReader reader = accessor.newReader(); LongIterator rangeFromBInclusive = reader.query( range( PROP_ID, "B", true, null, false ) ); assertThat( PrimitiveLongCollections.asArray( rangeFromBInclusive ), LongArrayMatcher.of( 2, 3 ) ); LongIterator rangeFromANonInclusive = reader.query( range( PROP_ID, "A", false, null, false ) ); assertThat( PrimitiveLongCollections.asArray( rangeFromANonInclusive ), LongArrayMatcher.of( 2, 3 ) ); LongIterator emptyLowInclusive = reader.query( range( PROP_ID, "", true, null, false ) ); assertThat( PrimitiveLongCollections.asArray( emptyLowInclusive ), LongArrayMatcher.of( PROP_ID, 2, 3, 4 ) ); LongIterator emptyUpperNonInclusive = reader.query( range( PROP_ID, "B", true, "", false ) ); assertThat( PrimitiveLongCollections.asArray( emptyUpperNonInclusive ), LongArrayMatcher.emptyArrayMatcher() ); LongIterator emptyInterval = reader.query( range( PROP_ID, "", true, "", true ) ); assertThat( PrimitiveLongCollections.asArray( emptyInterval ), LongArrayMatcher.of( 4 ) ); LongIterator emptyAllNonInclusive = reader.query( range( PROP_ID, "", false, null, false ) ); assertThat( PrimitiveLongCollections.asArray( emptyAllNonInclusive ), LongArrayMatcher.of( PROP_ID, 2, 3 ) ); LongIterator nullNonInclusive = reader.query( range( PROP_ID, (String) null, false, null, false ) ); assertThat( PrimitiveLongCollections.asArray( nullNonInclusive ), LongArrayMatcher.of( PROP_ID, 2, 3, 4 ) ); LongIterator nullInclusive = reader.query( range( PROP_ID, (String) null, false, null, false ) ); assertThat( PrimitiveLongCollections.asArray( nullInclusive ), LongArrayMatcher.of( PROP_ID, 2, 3, 4 ) ); }
@Test public void mustReportUniqueValuesFromOverlappingIterators() { // given AtomicInteger closeCounter = new AtomicInteger(); long[] firstIter = {0L, 2L, Long.MAX_VALUE}; long[] secondIter = { 1L, 3L }; long[] thirdIter = {0L, 3L }; long[] expected = {0L, 1L, 2L, 3L, Long.MAX_VALUE}; List<PrimitiveLongResourceIterator> iterators = asMutableList( iterator( closeCounter::incrementAndGet, firstIter ), iterator( closeCounter::incrementAndGet, secondIter ), iterator( closeCounter::incrementAndGet, thirdIter ) ); // when CompositeLabelScanValueIterator iterator = new CompositeLabelScanValueIterator( iterators, false ); // then assertArrayEquals( expected, PrimitiveLongCollections.asArray( iterator ) ); // when iterator.close(); // then assertEquals( "expected close count", 3, closeCounter.get() ); }
@Test public void mustOnlyReportValuesReportedByAll() { // given AtomicInteger closeCounter = new AtomicInteger(); long[] firstIter = {0L, Long.MAX_VALUE}; long[] secondIter = {0L, 1L, Long.MAX_VALUE}; long[] thirdIter = {0L, 1L, 2L, Long.MAX_VALUE}; long[] expected = {0L, Long.MAX_VALUE}; List<PrimitiveLongResourceIterator> iterators = asMutableList( iterator( closeCounter::incrementAndGet, firstIter ), iterator( closeCounter::incrementAndGet, secondIter ), iterator( closeCounter::incrementAndGet, thirdIter ) ); // when CompositeLabelScanValueIterator iterator = new CompositeLabelScanValueIterator( iterators, true ); // then assertArrayEquals( expected, PrimitiveLongCollections.asArray( iterator ) ); // when iterator.close(); // then assertEquals( "expected close count", 3, closeCounter.get() ); }
@Test public void mustReportUniqueValuesFromOverlappingIteratorsWithOneEmpty() { // given AtomicInteger closeCounter = new AtomicInteger(); long[] firstIter = {0L, 2L, Long.MAX_VALUE}; long[] secondIter = { 1L, 3L }; long[] thirdIter = {0L, 3L }; long[] fourthIter = {/* Empty */ }; long[] expected = {0L, 1L, 2L, 3L, Long.MAX_VALUE}; List<PrimitiveLongResourceIterator> iterators = asMutableList( iterator( closeCounter::incrementAndGet, firstIter ), iterator( closeCounter::incrementAndGet, secondIter ), iterator( closeCounter::incrementAndGet, thirdIter ), iterator( closeCounter::incrementAndGet, fourthIter ) ); // when CompositeLabelScanValueIterator iterator = new CompositeLabelScanValueIterator( iterators, false ); // then assertArrayEquals( expected, PrimitiveLongCollections.asArray( iterator ) ); // when iterator.close(); // then assertEquals( "expected close count", 4, closeCounter.get() ); }
@Test public void mustOnlyReportValuesReportedByAllWithOneEmpty() { // given AtomicInteger closeCounter = new AtomicInteger(); long[] firstIter = {0L, Long.MAX_VALUE}; long[] secondIter = {0L, 1L, Long.MAX_VALUE}; long[] thirdIter = {0L, 1L, 2L, Long.MAX_VALUE}; long[] fourthIter = {/* Empty */ }; long[] expected = { }; List<PrimitiveLongResourceIterator> iterators = asMutableList( iterator( closeCounter::incrementAndGet, firstIter ), iterator( closeCounter::incrementAndGet, secondIter ), iterator( closeCounter::incrementAndGet, thirdIter ), iterator( closeCounter::incrementAndGet, fourthIter ) ); // when CompositeLabelScanValueIterator iterator = new CompositeLabelScanValueIterator( iterators, true ); // then assertArrayEquals( expected, PrimitiveLongCollections.asArray( iterator ) ); // when iterator.close(); // then assertEquals( "expected close count", 4, closeCounter.get() ); }
@Test public void shouldGetRelationships() { RelationshipChangesForNode changes = new RelationshipChangesForNode( RelationshipChangesForNode.DiffStrategy.ADD ); final int TYPE = 2; changes.addRelationship( 1, TYPE, INCOMING ); changes.addRelationship( 2, TYPE, OUTGOING ); changes.addRelationship( 3, TYPE, OUTGOING ); changes.addRelationship( 4, TYPE, LOOP ); changes.addRelationship( 5, TYPE, LOOP ); changes.addRelationship( 6, TYPE, LOOP ); LongIterator rawRelationships = changes.getRelationships(); assertThat( PrimitiveLongCollections.asArray( rawRelationships ), ids( 1, 2, 3, 4, 5, 6 ) ); }
@Test public void shouldAddLabels() throws Exception { // GIVEN ControlledInserter inserter = new ControlledInserter(); long[] expected = new long[NODE_COUNT]; try ( NativeLabelScanWriter writer = new NativeLabelScanWriter( max( 5, NODE_COUNT / 100 ), NativeLabelScanWriter.EMPTY ) ) { writer.initialize( inserter ); // WHEN for ( int i = 0; i < NODE_COUNT * 3; i++ ) { NodeLabelUpdate update = randomUpdate( expected ); writer.write( update ); } } // THEN for ( int i = 0; i < LABEL_COUNT; i++ ) { long[] expectedNodeIds = nodesWithLabel( expected, i ); long[] actualNodeIds = asArray( new LabelScanValueIterator( inserter.nodesFor( i ), new ArrayList<>(), NO_ID ) ); assertArrayEquals( "For label " + i, expectedNodeIds, actualNodeIds ); } }
@Test public void addUpdates() throws Exception { populator = newPopulator(); List<IndexEntryUpdate<?>> updates = Arrays.asList( add( 1, schemaDescriptor, "aaa" ), add( 2, schemaDescriptor, "bbb" ), add( 3, schemaDescriptor, "ccc" ) ); populator.add( updates ); index.maybeRefreshBlocking(); try ( IndexReader reader = index.getIndexReader() ) { LongIterator allEntities = reader.query( IndexQuery.exists( 1 ) ); assertArrayEquals( new long[]{1, 2, 3}, PrimitiveLongCollections.asArray( allEntities ) ); } }
@Test public void doNotIterateTwiceOverSameElementsWhenItsPartOfSourceAndAdded() { LongIterator source = iterator( 4L, 5L ); LongSet added = LongHashSet.newSetWith( 1L, 4L ); LongSet removed = LongHashSet.newSetWith( 3L ); LongIterator iterator = DiffApplyingPrimitiveLongIterator.augment( source, added, removed ); Long[] values = ArrayUtils.toObject( asArray( iterator ) ); assertThat( values, arrayContainingInAnyOrder( 1L, 4L, 5L ) ); assertThat( values, arrayWithSize( 3 ) ); }
@Test void addUpdates() throws Exception { populator = newPopulator(); List<IndexEntryUpdate<?>> updates = Arrays.asList( add( 1, labelSchemaDescriptor, "foo" ), add( 2, labelSchemaDescriptor, "bar" ), add( 42, labelSchemaDescriptor, "bar" ) ); populator.add( updates ); index.maybeRefreshBlocking(); try ( IndexReader reader = index.getIndexReader() ) { int propertyKeyId = labelSchemaDescriptor.getPropertyId(); LongIterator allEntities = reader.query( IndexQuery.exists( propertyKeyId ) ); assertArrayEquals( new long[]{1, 2, 42}, PrimitiveLongCollections.asArray( allEntities ) ); } }