protected FulltextSearchResults read(final SearchCriterion... searchCriterions) throws UnexpectedInputException, ParseException, NonTransientResourceException { Assert.notNull(searchCriterions); ResultsFormat resultsFormat = new ResultsFormat(new ArrayList<FieldRequest>()); FulltextSearchQuery searchQuery = new FulltextSearchQuery(amountOfReadItems, bufferSize, resultsFormat, searchCriterions); FulltextSearchResults results = fulltextIndexService.performSearch(searchQuery); amountOfReadItems += results.getSize(); return results; }
ResultsFormat format = transformResultsFormat(fromObject.getResultsFormat()); FulltextSearchQuery query = new FulltextSearchQuery(first, size, format); query.addAdditionalParam(transformAdditionalParam(additionalParamProto)); query.addCriterion(transformCriterion(searchCriterionProto)); query.addOrder(transformOrder(orderProto)); query.addSubquery(convertFrom(searchQueryProto)); query.setFilterName(fromObject.getFilterName()); query.setFacet(transformFacet(fromObject.getFacet()));
public FulltextIterator(FulltextIndexService service, ResultsFormat format, List<Order> order, List<SearchCriterion> criteria, String cursorMark, int pageSize) { this.service = service; query = new FulltextSearchQuery(0, pageSize, format, order, Arrays.asList(new FieldCriterion("*", "*"))); query.setCursorMark(cursorMark); query.setUseCursor(true); for(SearchCriterion criterion:criteria){ query.addFilterCriterion(criterion); } FulltextSearchResults results = prepareNextResults(); updateContext(results); totalCount = results.getCount(); } public FulltextIterator(FulltextIndexService service, ResultsFormat format, Order order, List<SearchCriterion> criteria, String cursorMark, int pageSize) {
private void addTransformedSearchCriterionToQuery(SearchCriterion baseCriterion, FulltextSearchQuery query, SearchCriterionTransformer[] transformFlow, SearchCriterionTransformerHint hint, SearchScheme scheme, boolean score) { for (SearchCriterionTransformer searchCriterionTransformer : transformFlow) { baseCriterion = searchCriterionTransformer.transform(baseCriterion, scheme, hint); } if (!isCriterionEmpty(baseCriterion)) { if(score){ query.addCriterion(baseCriterion); }else { query.addFilterCriterion(baseCriterion); } } }
/** * Construct query using SearchQuery object. <BR> * <B><I>Only criteria and subqueries are used from given object. Any other * parameters are ommited.</I></B> * * @param searchQuery the search query * @param schema the fields metadata * @param depth the depth * @return the single query * */ private String constructQueryWithDetectedQueryType(final FulltextSearchQuery searchQuery, final FulltextIndexSchema schema, final long depth) { final QueryType queryType = detectQueryType(searchQuery.getCriteria(), schema); return SolrConstant.queryTypePrefix(queryType) + constructQuery(searchQuery.getCriteria(), searchQuery.getSubqueries(), schema, depth); }
@Override @Cacheable(value = CACHE_NAME) public List<String> preapareDataSets() { int batchSize = 1; ResultsFormat resultsFormat = new ResultsFormat( new FieldRequest(CollectionIndexFieldConstants.FIELD_EXID, true)); FulltextSearchQuery searchQuery = new FulltextSearchQuery(0, batchSize, resultsFormat , new FieldCriterion(ALL, ALL, SearchOperator.AND)); Facet facet = new Facet(); facet.addFieldFacet(PublicationIndexFieldConstants.FIELD_DATASET); searchQuery.setFacet(facet); return portalIndexSearchService.performSearch(searchQuery, ApplicationConstants.DEFAULT_DATASET); }
if (searchQuery.isUseCursor()) { if (StringUtils.isNotBlank(searchQuery.getCursorMark())) { solrQuery.set(CursorMarkParams.CURSOR_MARK_PARAM, searchQuery.getCursorMark()); } else { solrQuery.set(CursorMarkParams.CURSOR_MARK_PARAM, CursorMarkParams.CURSOR_MARK_START); solrQuery.setStart(searchQuery.getFirst()); int size = searchQuery.getSize(); if (noSizeLimit(size)) { size = SolrConstant.QUERY_DEFAULT_SIZE; if (searchQuery.getOrders() != null) { addSortOrder(searchQuery, solrQuery, schema); final String query = queryBuilder.constructQueryWithDetectedQueryType(searchQuery.getCriteria(), searchQuery.getSubqueries(), schema); if (LOG.isDebugEnabled()) { LOG.debug("Query constructed: {}", query); final String fieldQuery = queryBuilder.constructQueryWithDetectedQueryType(searchQuery.getFilterQueryCriteria(), new ArrayList<FulltextSearchQuery>(), schema); if (LOG.isDebugEnabled()) { solrQuery.setIncludeScore(searchQuery.isIncludeScore()); if (StringUtils.isNotEmpty(fieldQuery)) { solrQuery.set(CommonParams.FQ, fieldQuery); mapFacetQuery(searchQuery.getFacet(), solrQuery, schema);
@Override public LuceneQueryContainer build(SearchRequest request) { AdvancedSearchRequest simpleRequest = (AdvancedSearchRequest) request; SearchScheme scheme = searchSchemes.get(request.getSearchScheme()); if (scheme == null) { throw new IllegalStateException("Scheme " + request.getSearchScheme() + " not found"); } @SuppressWarnings("deprecation") FulltextSearchQuery searchQuery = getSearchCriterions(scheme, true, simpleRequest, new FulltextSearchQuery()); applyOrder(simpleRequest, searchQuery, scheme); applyParameters(simpleRequest, searchQuery); List<String> filters = new LinkedList<String>(); log(searchQuery); List<FieldRequest> fieldRequests = new LinkedList<FieldRequest>(); for (Map.Entry<String, Boolean> requestedField : scheme.getRequestedFields().entrySet()) { fieldRequests.add(new FieldRequest(requestedField.getKey(), requestedField.getValue())); } ResultsFormat resultsFormat = new ResultsFormat(fieldRequests); searchQuery.setFormat(resultsFormat); return new LuceneQueryContainer(searchQuery, filters); }
private void populateFacets(FulltextSearchQuery query, SearchQuery sourceQuery) { String fieldFacet = sourceQuery.getFacetField(); if (StringUtils.isNotEmpty(fieldFacet)) { Facet facet = new Facet(); FacetParameters params = new FacetParameters().setMinCount(1); facet.addFieldFacet(fieldFacet, params); query.setFacet(facet); } }
private void applyOrder(AdvancedSearchRequest request, FulltextSearchQuery searchQuery, SearchScheme scheme) { if (StringUtils.isNotEmpty(request.getOrderField())) { String orderField = request.getOrderField(); List<String> fields = getSortByFieldName(scheme, orderField); applyOrderFields(request, searchQuery, scheme, fields, request.isOrderAscending()); } if (CollectionUtils.isEmpty(searchQuery.getOrders())) { searchQuery.addOrder(Order.relevanceOrder()); List<String> fields = getSortByFieldName(scheme, "sortdate"); if (!fields.isEmpty()) { applyOrderFields(request, searchQuery, scheme, fields, true); } } }
@Override public MetadataSearchResults search(final SearchRequest searchRequest, SearchErrors errors) { final LuceneQueryContainer queryContainer = searchQueryFactory.build(searchRequest); errors.addAllErrors(((AdvancedSearchRequest) searchRequest).getErrors().getErrors()); final FulltextSearchQuery searchQuery = queryContainer.getSearchQuery(); logger.debug("Searching schema {} for {}", searchRequest.getSearchScheme(), searchQuery); if (CollectionUtils.isEmpty(searchQuery.getCriteria()) && CollectionUtils.isEmpty(searchQuery.getFilterQueryCriteria())) { return new MetadataSearchResultsImpl(); } final MetadataSearchResults results ; try { results = acquireResults(searchQuery); } catch (InvalidQueryException ex) { return new MetadataSearchResultsImpl(); } return results; }
private void applyOrderFields(AdvancedSearchRequest request, FulltextSearchQuery searchQuery, SearchScheme scheme, List<String> fields, final boolean baseOrder) { for (String field : fields) { if (StringUtils.isNotEmpty(field)) { boolean order = baseOrder; if ((scheme.getSpecialFieldTypes().containsKey(field) && scheme.getSpecialFieldTypes().get(field).equals("dateType")) || (IndexFieldConstants.FOR_SORT_PREFIX + PublicationIndexFieldConstants.FIELD_DATE).equals(request.getOrderField())) { order = !order; } searchQuery.addOrder(new Order(field, order)); } } }
@Override @RequiresServiceRole(roleName="READ") public void validateQuery(final FulltextSearchQuery query) { final QueryBuilder queryBuilder = new QueryBuilder(); queryBuilder.detectQueryType(query.getCriteria(), indexManager .getIndex().getSchema()); }
protected FulltextSearchQuery getSearchCriterions(SearchScheme scheme, boolean doAppendFilteringCriterion, AdvancedSearchRequest request, FulltextSearchQuery query) { SearchCriterion baseCriterion = conditionsToCriterionTransformer.transformRequestToSearchCriterion(request); SearchCriterionTransformerHint hint = new SearchCriterionTransformerHint(); addTransformedSearchCriterionToQuery(baseCriterion, query, transformFlow, hint, scheme,true); request.setErrors(hint.getErrors().group()); if (CollectionUtils.isNotEmpty(request.getErrors().getErrors())) { log.warn("Errors in search {} ", request.getErrors().getErrors()); } applyFacets(scheme, query, request); applyForceAndConditions(scheme, query, request); // filtering if (doAppendFilteringCriterion && scheme.getAdditionalCriterions() != null) { for (SearchCriterion additionalCriterion : scheme.getAdditionalCriterions()) { query.addFilterCriterion(additionalCriterion); } } return query; }
private void tryFacet() { int batchSize = 1; ResultsFormat resultsFormat = new ResultsFormat(new FieldRequest(pl.edu.icm.synat.logic.index.publication.CollectionIndexFieldConstants.FIELD_EXID, true)); FulltextSearchQuery searchQuery = null; searchQuery = new FulltextSearchQuery(0, batchSize, resultsFormat, new FieldCriterion("*", "*", SearchOperator.AND)); Facet facet = new Facet(); facet.addFieldFacet(PublicationIndexFieldConstants.FIELD_TYPE); searchQuery.setFacet(facet); FulltextSearchResults searchResults = indexService.performSearch(searchQuery); FieldFacetResult facetResult = searchResults.getFacetResult().getFieldFacetResult(PublicationIndexFieldConstants.FIELD_TYPE); Set<Entry<String,Long>> entrySet = facetResult.getValues().entrySet(); for (Entry<String, Long> entry : entrySet) { System.out.println("["+entry.getKey()+"]="+entry.getValue()); } }
private void applyFacets(SearchScheme scheme, FulltextSearchQuery query, AdvancedSearchRequest request) { List<FieldCondition> facetsConditions = extractConditions(request, AdvancedFieldConditionType.FACET); SearchCriterionTransformerHint hints = new SearchCriterionTransformerHint(true, true); if (CollectionUtils.isNotEmpty(facetsConditions)) { SearchCriterion criterions = conditionsToCriterionTransformer.transformConditionsListToSearchCriterion(facetsConditions, SearchOperator.AND); addTransformedSearchCriterionToQuery(criterions, query, transformFlow, hints, scheme, false); } if (!Boolean.parseBoolean(request.getProperty(SearchRequestProperties.FORCE_FACET_DISABLED))) { Facet f = retrieveSchemeDefinedFacets(scheme, hints.getFieldsUsed(), request); query.setFacet(f); } }
private FulltextSearchQuery prepareSearchQuery(final String id, final String type) { final List<FieldRequest> fieldRequests = new ArrayList<FieldRequest>(); fieldRequests.add(new FieldRequest(getSortField(FIELD_NAME), false)); fieldRequests.add(new FieldRequest(FIELD_EXID, false)); String schema = transform.get(type.toLowerCase()); FieldCriterion criterion = new FieldCriterion(FIELD_BASE + schema, IdentifierFormatter.simplify(id), SearchOperator.AND); final ResultsFormat resultsFormat = new ResultsFormat(fieldRequests); final FulltextSearchQuery searchQuery = new FulltextSearchQuery(0, 10, resultsFormat, criterion); return searchQuery; }
private FulltextSearchResults getFacet(String facetFieldName, SearchCriterion criterion, SuggestionsQuery query) { ResultsFormat results = new ResultsFormat(new FieldRequest(facetFieldName)); FulltextSearchQuery indexQuery = new FulltextSearchQuery(query.getPageNo() * query.getPageSize(), query.getPageSize(), results, criterion); Facet facet = new Facet(); facet.addFieldFacet(facetFieldName); FacetParameters parameters = new FacetParameters(); parameters.setMinCount(1); facet.setParameters(parameters); indexQuery.setFacet(facet); FulltextSearchResults result = peopleIndex.performSearch(indexQuery); return result; }
private FulltextSearchQuery prepareSearchQuery(final Map<String, String> params, final int first, final int pageSize) { final List<FieldRequest> fieldRequests = new ArrayList<FieldRequest>(); fieldRequests.add(new FieldRequest(IndexSchemaFactoryUtils.getSortField(FIELD_NAME), false)); fieldRequests.add(new FieldRequest(FIELD_VISIBILITY, false)); fieldRequests.add(new FieldRequest(FIELD_TYPE, false)); fieldRequests.add(new FieldRequest(FIELD_EXID, false)); fieldRequests.add(new FieldRequest(FIELD_DATE+ SEP + "creationTimestamp", false)); List<FieldCriterion> criterions = new LinkedList<>(); for (Entry<String, String> entry : params.entrySet()) { criterions.add(new FieldCriterion(entry.getKey(), entry.getValue(), SearchOperator.AND)); } final ResultsFormat resultsFormat = new ResultsFormat(fieldRequests); if(criterions.isEmpty()){ criterions.add(new FieldCriterion("*", "*")); } final FulltextSearchQuery searchQuery = new FulltextSearchQuery(first, pageSize, resultsFormat, criterions.toArray(new FieldCriterion[criterions.size()])); return searchQuery; }
private FulltextSearchQuery prepareSearchQuery(final Map<String, String> params, final int first, final int pageSize) { final List<FieldRequest> fieldRequests = new ArrayList<FieldRequest>(); fieldRequests.add(new FieldRequest(IndexSchemaFactoryUtils.getSortField(FIELD_NAME), false)); fieldRequests.add(new FieldRequest(FIELD_VISIBILITY, false)); fieldRequests.add(new FieldRequest(FIELD_TYPE, false)); fieldRequests.add(new FieldRequest(FIELD_EXID, false)); fieldRequests.add(new FieldRequest(FIELD_DATE+ SEP + "creationTimestamp", false)); List<FieldCriterion> criterions = new LinkedList<>(); for (Entry<String, String> entry : params.entrySet()) { criterions.add(new FieldCriterion(entry.getKey(), entry.getValue(), SearchOperator.AND)); } final ResultsFormat resultsFormat = new ResultsFormat(fieldRequests); if(criterions.isEmpty()){ criterions.add(new FieldCriterion("*", "*")); } final FulltextSearchQuery searchQuery = new FulltextSearchQuery(first, pageSize, resultsFormat, criterions.toArray(new FieldCriterion[criterions.size()])); return searchQuery; }