@Override QueryResponse perform() { HSQuery query = queryDefinition.getHsQuery(); query.afterDeserialise(getSearchFactory()); try (DocumentExtractor ignored = query.queryDocumentExtractor()) { int resultSize = query.queryResultSize(); return new QueryResponse(resultSize); } } }
@Override public List<E> list() throws SearchException { hSearchQuery.getTimeoutManager().start(); final List<EntityInfo> entityInfos = hSearchQuery.queryEntityInfos(); return (List<E>) getResultLoader().load(entityInfos); }
public void setMaxResults(int maxResults) { this.maxResults = maxResults; if (hsQuery != null) { hsQuery.maxResults(maxResults); } }
private Loader getProjectionLoader(ObjectLoaderBuilder loaderBuilder) { ProjectionLoader loader = new ProjectionLoader(); loader.init( session, hSearchQuery.getExtendedSearchIntegrator(), resultTransformer, loaderBuilder, hSearchQuery.getProjectedFields(), hSearchQuery.getTimeoutManager(), hSearchQuery.hasThisProjection() ); return loader; }
@Benchmark @Threads(20) public void queryBooksByBestRating(QueryEngineHolder eh, Blackhole bh) { SearchIntegrator searchIntegrator = eh.si; Query luceneQuery = searchIntegrator.buildQueryBuilder() .forEntity( BookEntity.class ) .get() .all() .createQuery(); long expectedIndexSize = eh.getExpectedIndexSize(); int maxResults = eh.getMaxResults(); HSQuery hsQuery = searchIntegrator.createHSQuery( luceneQuery, BookEntity.class ); hsQuery.sort( new Sort( new SortField( "rating", SortField.Type.FLOAT, true ) ) ); hsQuery.maxResults( maxResults ); int queryResultSize = hsQuery.queryResultSize(); List<EntityInfo> queryEntityInfos = hsQuery.queryEntityInfos(); if ( eh.isQuerySync() && queryResultSize != expectedIndexSize ) { throw new RuntimeException( "Unexpected index size" ); } if ( maxResults != queryEntityInfos.size() ) { throw new RuntimeException( "Unexpected resultset size" ); } bh.consume( queryEntityInfos ); }
@Test(expected = ClassCastException.class) public void singleField_numericFieldBridge_missingValue_use_nonRaw() throws Exception { Sort sort = builder().sort() .byField( "fieldBridgedNumericField" ) .onMissingValue().use( new WrappedDoubleValue( 1.5d ) ) .createSort(); sfHolder.getSearchFactory().createHSQuery( new MatchAllDocsQuery(), IndexedEntry.class ) .sort( sort ) .queryEntityInfos(); }
@Benchmark @GroupThreads(5) @Group("concurrentReadWriteTest") public void readWriteTestReader(QueryEngineHolder eh, Blackhole bh) { SearchIntegrator searchIntegrator = eh.si; Query luceneQuery = searchIntegrator.buildQueryBuilder() .forEntity( BookEntity.class ) .get() .all() .createQuery(); int maxResults = eh.getMaxResults(); HSQuery hsQuery = searchIntegrator.createHSQuery( luceneQuery, BookEntity.class ); hsQuery.maxResults( maxResults ); int queryResultSize = hsQuery.queryResultSize(); List<EntityInfo> queryEntityInfos = hsQuery.queryEntityInfos(); bh.consume( queryEntityInfos ); bh.consume( queryResultSize ); }
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() ); }
/** * @return The result size of the query. */ @Override public int getResultSize() { return hSearchQuery.queryResultSize(); }
HSQuery query = queryContext.getExtendedSearchIntegrator().createHSQuery( findById, queryContext.getEntityType().getPojoType() ); List<EntityInfo> entityInfos = query .maxResults( 1 ) .projection( HSQuery.DOCUMENT_ID ) .queryEntityInfos(); if ( entityInfos.size() == 0 ) { if ( inputType == ID ) {
@Test(expected = SearchException.class) public void searchBeyondMaxResultWindow() throws Exception { generateData( 0, DEFAULT_MAX_RESULT_WINDOW + 10 ); Query query = builder().all().createQuery(); getQuery( query ) .firstResult( DEFAULT_MAX_RESULT_WINDOW + 1 ).maxResults( 5 ) .queryEntityInfos(); }
public ListAssert asResultProjectionsAsLists() { HSQuery hsQuery = getHSQuery(); List<EntityInfo> results = hsQuery.queryEntityInfos(); List<List<Object>> projections = results.stream() .map( EntityInfo::getProjection ) .map( Arrays::asList ) // Take advantage of List.equals when calling ListAssert.containsExactly, for instance .collect( Collectors.toList() ); return Assertions.assertThat( projections ) .as( "Projections of results of query " + toString( hsQuery ) ); }
private HSQuery getQuery(Query luceneQuery) { ExtendedSearchIntegrator sf = sfHolder.getSearchFactory(); HSQuery hsQuery = sf.createHSQuery( luceneQuery, IndexedObject.class ); return hsQuery .projection( "id" ) .sort( new Sort( new SortField( "idSort", SortField.Type.INT ) ) ); }
@Override public ResultIterator<E> iterator(FetchOptions fetchOptions) throws SearchException { if (fetchOptions.getFetchMode() == FetchOptions.FetchMode.EAGER) { hSearchQuery.getTimeoutManager().start(); List<EntityInfo> entityInfos = hSearchQuery.queryEntityInfos(); return filterNulls(new EagerIterator<>(entityInfos, getResultLoader(), fetchOptions.getFetchSize())); } else if (fetchOptions.getFetchMode() == FetchOptions.FetchMode.LAZY) { DocumentExtractor extractor = hSearchQuery.queryDocumentExtractor(); //triggers actual Lucene search return filterNulls(new LazyIterator<>(extractor, getResultLoader(), fetchOptions.getFetchSize())); } else { throw new IllegalArgumentException("Unknown FetchMode " + fetchOptions.getFetchMode()); } }
public void initialize(AdvancedCache<?, ?> cache) { if (hsQuery == null) { QueryEngine queryEngine = getQueryEngine(cache); HsQueryRequest hsQueryRequest; if (indexedType != null && sortableFields != null) { IndexedTypeMap<CustomTypeMetadata> metadata = createMetadata(); hsQueryRequest = queryEngine.createHsQuery(queryString, metadata, namedParameters); } else { hsQueryRequest = queryEngine.createHsQuery(queryString, null, namedParameters); } hsQuery = hsQueryRequest.getHsQuery(); sort = hsQueryRequest.getSort(); hsQuery.firstResult(firstResult); hsQuery.maxResults(maxResults); hsQuery.projection(hsQueryRequest.getProjections()); } }
@Override public FacetManager getFacetManager() { return hSearchQuery.getFacetManager(); }
@Override public FullTextQueryImpl setSort(Sort sort) { hSearchQuery.sort( sort ); return this; }
@Override public FullTextQueryImpl setProjection(String... fields) { hSearchQuery.projection( fields ); return this; }
/** * Decide which object loader to use depending on the targeted entities. If there is only a single entity targeted * a <code>QueryLoader</code> can be used which will only execute a single query to load the entities. If more than * one entity is targeted a <code>MultiClassesQueryLoader</code> must be used. We also have to consider whether * projections or <code>Criteria</code> are used. * * @return The loader instance to use to load the results of the query. */ private Loader getLoader() { ObjectLoaderBuilder loaderBuilder = new ObjectLoaderBuilder() .criteria( criteria ) .targetedEntities( hSearchQuery.getTargetedEntities() ) .indexedTargetedEntities( hSearchQuery.getIndexedTargetedEntities().toPojosSet() ) .session( session ) .searchFactory( hSearchQuery.getExtendedSearchIntegrator() ) .timeoutManager( hSearchQuery.getTimeoutManager() ) .lookupMethod( objectLookupMethod ) .retrievalMethod( databaseRetrievalMethod ); if ( hSearchQuery.getProjectedFields() != null ) { return getProjectionLoader( loaderBuilder ); } else { return loaderBuilder.buildLoader(); } }
private String toString(HSQuery query) { StringBuilder builder = new StringBuilder(); if ( StringHelper.isNotEmpty( description ) ) { builder.append( description ).append( " - " ); } builder.append( "<" ).append( query.getQueryString() ).append( ">" ) .append( " from <" ).append( query.getTargetedEntities() ).append( ">" ); String[] projected = query.getProjectedFields(); if ( projected != null && projected.length > 0 ) { builder.append( " with projections <" ).append( query.getProjectedFields() ).append( ">" ); } return builder.toString(); } }