protected List<Long> query( IndexQuery... predicates ) throws Exception { try ( IndexReader reader = accessor.newReader(); ) { SimpleNodeValueClient nodeValueClient = new SimpleNodeValueClient(); reader.query( nodeValueClient, IndexOrder.NONE, false, predicates ); List<Long> list = new LinkedList<>(); while ( nodeValueClient.next() ) { long entityId = nodeValueClient.reference; if ( passesFilter( entityId, predicates ) ) { list.add( entityId ); } } Collections.sort( list ); return list; } }
public boolean next() { if ( progressor.next() ) { return true; } closeProgressor(); return false; }
@Test void defaultQueryImplementationMustThrowForUnsupportedIndexOrder() { // Given IndexReader indexReader = stubIndexReader(); // Then String expectedMessage = String.format( "This reader only have support for index order %s. Provided index order was %s.", IndexOrder.NONE, IndexOrder.ASCENDING ); UnsupportedOperationException operationException = assertThrows( UnsupportedOperationException.class, () -> indexReader.query( new SimpleNodeValueClient(), IndexOrder.ASCENDING, false, IndexQuery.exists( 1 ) ) ); assertEquals( expectedMessage, operationException.getMessage() ); }
List<Long> assertClientReturnValuesInOrder( SimpleNodeValueClient client, IndexOrder order ) { List<Long> seenIds = new ArrayList<>(); Value[] prevValues = null; Value[] values; int count = 0; while ( client.next() ) { count++; seenIds.add( client.reference ); values = client.values; if ( order == IndexOrder.ASCENDING ) { assertLessThanOrEqualTo( prevValues, values ); } else if ( order == IndexOrder.DESCENDING ) { assertLessThanOrEqualTo( values, prevValues ); } else { Assert.fail( "Unexpected order " + order ); } prevValues = values; } return seenIds; }
List<Long> assertInOrder( IndexOrder order, IndexQuery... predicates ) throws Exception { List<Long> actualIds; if ( order == IndexOrder.NONE ) { actualIds = query( predicates ); } else { SimpleNodeValueClient client = new SimpleNodeValueClient(); try ( AutoCloseable ignore = query( client, order, predicates ) ) { actualIds = assertClientReturnValuesInOrder( client, order ); } } return actualIds; }
private void exactMatchOnAllValues( List<Value> values ) throws IndexNotApplicableKernelException { try ( IndexReader indexReader = accessor.newReader() ) { SimpleNodeValueClient client = new SimpleNodeValueClient(); for ( Value value : values ) { IndexQuery.ExactPredicate exact = IndexQuery.exact( descriptor.schema().getPropertyId(), value ); indexReader.query( client, IndexOrder.NONE, true, exact ); // then assertTrue( client.next() ); assertEquals( value, client.values[0] ); assertFalse( client.next() ); } } } }
@Test public void throwForUnsupportedIndexOrder() throws Exception { // given // Unsupported index order for query try ( IndexReader reader = accessor.newReader() ) { IndexOrder unsupportedOrder = IndexOrder.DESCENDING; IndexQuery.ExactPredicate unsupportedQuery = IndexQuery.exact( 0, PointValue.MAX_VALUE ); // <- Any spatial value would do // then expected.expect( UnsupportedOperationException.class ); expected.expectMessage( CoreMatchers.allOf( CoreMatchers.containsString( "unsupported order" ), CoreMatchers.containsString( unsupportedOrder.toString() ), CoreMatchers.containsString( unsupportedQuery.toString() ) ) ); // when reader.query( new SimpleNodeValueClient(), unsupportedOrder, false, unsupportedQuery ); } }
SimpleNodeValueClient client = new SimpleNodeValueClient(); reader.query( client, IndexOrder.NONE, true, supportedQuery ); while ( client.next() )
private void shouldRangeSeekInOrder( IndexOrder order, Object o0, Object o1, Object o2, Object o3, Object o4, Object o5 ) throws Exception { IndexQuery range = range( 100, Values.of( o0 ), true, Values.of( o5 ), true ); IndexOrder[] indexOrders = orderCapability( range ); Assume.assumeTrue( "Assume support for order " + order, ArrayUtils.contains( indexOrders, order ) ); updateAndCommit( asList( add( 1, descriptor.schema(), o0 ), add( 1, descriptor.schema(), o5 ), add( 1, descriptor.schema(), o1 ), add( 1, descriptor.schema(), o4 ), add( 1, descriptor.schema(), o2 ), add( 1, descriptor.schema(), o3 ) ) ); SimpleNodeValueClient client = new SimpleNodeValueClient(); try ( AutoCloseable ignored = query( client, order, range ) ) { List<Long> seenIds = assertClientReturnValuesInOrder( client, order ); assertThat( seenIds.size(), equalTo( 6 ) ); } }
IndexReader referenceReader = referenceAccessor.newReader() ) SimpleNodeValueClient entries = new SimpleNodeValueClient(); SimpleNodeValueClient referenceEntries = new SimpleNodeValueClient(); reader.query( entries, IndexOrder.NONE, hasValues, IndexQuery.exists( 0 ) ); referenceReader.query( referenceEntries, IndexOrder.NONE, hasValues, IndexQuery.exists( 0 ) ); while ( referenceEntries.next() ) assertTrue( entries.next() ); assertEquals( referenceEntries.reference, entries.reference ); if ( hasValues ) assertFalse( entries.next() );
private void shouldSeekInOrderExactWithRange( IndexOrder order, Object o0, Object o1, Object o2, Object o3, Object o4, Object o5 ) throws Exception { Object baseValue = 1; // Todo use random value instead IndexQuery exact = exact( 100, baseValue ); IndexQuery range = range( 200, Values.of( o0 ), true, Values.of( o5 ), true ); IndexOrder[] indexOrders = orderCapability( exact, range ); Assume.assumeTrue( "Assume support for order " + order, ArrayUtils.contains( indexOrders, order ) ); updateAndCommit( asList( add( 1, descriptor.schema(), baseValue, o0 ), add( 1, descriptor.schema(), baseValue, o5 ), add( 1, descriptor.schema(), baseValue, o1 ), add( 1, descriptor.schema(), baseValue, o4 ), add( 1, descriptor.schema(), baseValue, o2 ), add( 1, descriptor.schema(), baseValue, o3 ) ) ); SimpleNodeValueClient client = new SimpleNodeValueClient(); try ( AutoCloseable ignored = query( client, order, exact, range ) ) { List<Long> seenIds = assertClientReturnValuesInOrder( client, order ); assertThat( seenIds.size(), equalTo( 6 ) ); } }
SimpleNodeValueClient client = new SimpleNodeValueClient(); reader.query( client, supportedOrder, true, supportedQuery ); int i = 0; while ( client.next() )