public HSQuery hsQuery(Class<?> ... classes) { return hsQuery( new MatchAllDocsQuery(), classes ); }
private List<Object[]> doQuery(Query mltQuery) { List<EntityInfo> results = helper.hsQuery( mltQuery, Coffee.class ) .projection( ProjectionConstants.ID, ProjectionConstants.SCORE ) .queryEntityInfos(); return results.stream().map( EntityInfo::getProjection ).collect( Collectors.toList() ); }
@Test @TestForIssue(jiraKey = "HSEARCH-1987") public void testNumericMappingOfEmbeddedFields() { List<EntityInfo> list = helper.hsQuery( ScoreBoard.class ) .projection( ProjectionConstants.DOCUMENT ) .queryEntityInfos(); assertEquals( 1, list.size() ); Document document = (Document) list.iterator().next().getProjection()[0]; IndexableField scoreNumeric = document.getField( "score_id" ); assertThat( scoreNumeric.numericValue() ).isEqualTo( 1 ); IndexableField beta = document.getField( "score_beta" ); assertThat( beta.numericValue() ).isEqualTo( 100 ); }
@Test @TestForIssue(jiraKey = "HSEARCH-1987") public void testOneOfSeveralFieldsIsNumeric() { List<EntityInfo> list = helper.hsQuery( TouristAttraction.class ) .projection( ProjectionConstants.DOCUMENT ) .queryEntityInfos(); assertEquals( 1, list.size() ); Document document = (Document) list.iterator().next().getProjection()[0]; IndexableField scoreNumeric = document.getField( "scoreNumeric" ); assertThat( scoreNumeric.numericValue() ).isEqualTo( 23 ); IndexableField scoreString = document.getField( "scoreString" ); assertThat( scoreString.numericValue() ).isNull(); assertThat( scoreString.stringValue() ).isEqualTo( "23" ); }
private HSQuery queryAll() { QueryBuilder qb = helper.queryBuilder( IndexedEntity.class ); return helper.hsQuery( IndexedEntity.class ) .sort( qb.sort().byField( "idSort" ).createSort() ); }
helper.assertThat( helper.hsQuery( IndexedEntity.class ) ) .matchesUnorderedIds( DOCUMENT_1, DOCUMENT_2, DOCUMENT_3 );
private void doDiscreteFacetingQuery() { QueryBuilder qb = helper.queryBuilder( FacetedEntity.class ); FacetingRequest request = qb.facet() .name( "myRequest" ) .onField( "stringField" ) .discrete() .includeZeroCounts( false ) .createFacetingRequest(); // Mainly, we're testing that executing the query with faceting enabled won't explode HSQuery hsQuery = helper.hsQuery( FacetedEntity.class ); hsQuery.getFacetManager().enableFaceting( request ); helper.assertThat( hsQuery ) .facets( "myRequest" ) .isEmpty(); }
@Test public void should() { QueryBuilder queryBuilder = helper.queryBuilder( IndexedEntity.class ); HSQuery query = helper.hsQuery( queryBuilder.bool() .should( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ) .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_1 ); query = helper.hsQuery( queryBuilder.bool() .should( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ) .should( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE2 ).createQuery() ) .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_1, DOCUMENT_2 ); }
@Test public void mustNot() { QueryBuilder queryBuilder = helper.queryBuilder( IndexedEntity.class ); HSQuery query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ).not() .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_2, DOCUMENT_3 ); query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ).not() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE3 ).createQuery() ).not() .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_2 ); }
@Test public void must() { QueryBuilder queryBuilder = helper.queryBuilder( IndexedEntity.class ); HSQuery query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ) .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_1 ); query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ) .must( queryBuilder.keyword().onField( "field2" ).matching( FIELD2_VALUE2 ).createQuery() ) .createQuery() ); helper.assertThat( query ).matchesNone(); query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ) .must( queryBuilder.keyword().onField( "field2" ).matching( FIELD2_VALUE1 ).createQuery() ) .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_1 ); }
@Test public void must_mustNot() { QueryBuilder queryBuilder = helper.queryBuilder( IndexedEntity.class ); HSQuery query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ) .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ).not() .createQuery() ); helper.assertThat( query ).matchesNone(); query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ) .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE2 ).createQuery() ).not() .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_1 ); }
private void doIntegerRangeFacetingQuery() { QueryBuilder qb = helper.queryBuilder( FacetedEntity.class ); FacetingRequest request = qb.facet() .name( "myRequest" ) .onField( "integerField" ) .range() .from( 0 ).to( 1000 ) .from( 1001 ).to( 1500 ) .includeZeroCounts( true ) .createFacetingRequest(); // Mainly, we're testing that executing the query with faceting enabled won't explode HSQuery hsQuery = helper.hsQuery( FacetedEntity.class ); hsQuery.getFacetManager().enableFaceting( request ); helper.assertThat( hsQuery ) .facets( "myRequest" ) .includes( "[0, 1000]", 0 ) .includes( "[1001, 1500]", 0 ) .only(); }
@Test public void should_mustNot() { QueryBuilder queryBuilder = helper.queryBuilder( IndexedEntity.class ); HSQuery query = helper.hsQuery( queryBuilder.bool() .should( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ) .should( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE3 ).createQuery() ) .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ).not() .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_3 ); }
private void doFloatRangeFacetingQuery() { QueryBuilder qb = helper.queryBuilder( FacetedEntity.class ); FacetingRequest request = qb.facet() .name( "myRequest" ) .onField( "floatField" ) .range() .from( 0.0f ).to( 1000.0f ).excludeLimit() .from( 1000.0f ).to( 1500.0f ).excludeLimit() .includeZeroCounts( true ) .createFacetingRequest(); // Mainly, we're testing that executing the query with faceting enabled won't explode HSQuery hsQuery = helper.hsQuery( FacetedEntity.class ); hsQuery.getFacetManager().enableFaceting( request ); helper.assertThat( hsQuery ) .facets( "myRequest" ) .includes( "[0.0, 1000.0)", 0 ) .includes( "[1000.0, 1500.0)", 0 ) .only(); }
@Test public void must_should() { QueryBuilder queryBuilder = helper.queryBuilder( IndexedEntity.class ); // A boolean predicate with must + should clauses: // documents should match regardless of whether should clauses match. // Non-matching "should" clauses HSQuery query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ) .should( queryBuilder.keyword().onField( "field2" ).matching( FIELD2_VALUE2 ).createQuery() ) .should( queryBuilder.keyword().onField( "field3" ).matching( FIELD3_VALUE3 ).createQuery() ) .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_1 ); // One matching and one non-matching "should" clause query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE2 ).createQuery() ) .should( queryBuilder.keyword().onField( "field2" ).matching( FIELD2_VALUE1 ).createQuery() ) .should( queryBuilder.keyword().onField( "field3" ).matching( FIELD3_VALUE3 ).createQuery() ) .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_2 ); }
HSQuery query = helper.hsQuery( queryBuilder.bool() .minimumShouldMatchPercent( -50 ) query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field4" ).matching( FIELD4_VALUE1AND2 ).createQuery() ) query = helper.hsQuery( queryBuilder.bool() .minimumShouldMatchPercent( -40 ) // The minimum should be rounded up to 2
HSQuery query = helper.hsQuery( queryBuilder.bool() .minimumShouldMatchPercent( 50 ) query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field4" ).matching( FIELD4_VALUE1AND2 ).createQuery() ) query = helper.hsQuery( queryBuilder.bool() .minimumShouldMatchPercent( 70 ) // The minimum should be rounded down to 2 query = helper.hsQuery( queryBuilder.bool() .minimumShouldMatchPercent( 100 )
@Test public void filter_should() { QueryBuilder queryBuilder = helper.queryBuilder( IndexedEntity.class ); // A boolean predicate with filter + should clauses: // documents should match regardless of whether should clauses match. // Non-matching "should" clauses HSQuery query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ).disableScoring() .should( queryBuilder.keyword().onField( "field2" ).matching( FIELD2_VALUE2 ).createQuery() ) .should( queryBuilder.keyword().onField( "field3" ).matching( FIELD3_VALUE3 ).createQuery() ) .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_1 ); // One matching and one non-matching "should" clause query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ).disableScoring() .should( queryBuilder.keyword().onField( "field2" ).matching( FIELD2_VALUE1 ).createQuery() ) .should( queryBuilder.keyword().onField( "field3" ).matching( FIELD3_VALUE3 ).createQuery() ) .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_1 ); }
@Test public void mustNot_should() { QueryBuilder queryBuilder = helper.queryBuilder( IndexedEntity.class ); // A boolean predicate with mustNot + should clauses: // documents should match only if at least one should clause matches // Non-matching "should" clauses HSQuery query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE2 ).createQuery() ).not() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE3 ).createQuery() ).not() .should( queryBuilder.keyword().onField( "field2" ).matching( FIELD2_VALUE2 ).createQuery() ) .should( queryBuilder.keyword().onField( "field3" ).matching( FIELD3_VALUE3 ).createQuery() ) .createQuery() ); helper.assertThat( query ) .matchesNone(); // One matching and one non-matching "should" clause query = helper.hsQuery( queryBuilder.bool() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ).not() .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE3 ).createQuery() ).not() .should( queryBuilder.keyword().onField( "field2" ).matching( FIELD2_VALUE2 ).createQuery() ) .should( queryBuilder.keyword().onField( "field3" ).matching( FIELD3_VALUE3 ).createQuery() ) .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_2 ); }