@Override QueryBuilder getQuery(String queryText) { return prefixAndPartialQuery(queryText, FIELD_NAME, FIELD_NAME) .boost(2f); } },
@Override public Stream<QueryBuilder> getQueries(ComponentTextSearchQuery query) { List<String> tokens = query.getQueryTextTokens(); if (tokens.isEmpty()) { return Stream.empty(); } List<String> lowerCaseTokens = tokens.stream().map(t -> t.toLowerCase(Locale.ENGLISH)).collect(MoreCollectors.toList()); BoolQueryBuilder queryBuilder = prefixAndPartialQuery(lowerCaseTokens, query.getFieldName(), SEARCH_PREFIX_CASE_INSENSITIVE_ANALYZER) .boost(2f); return Stream.of(queryBuilder); } },
@Override QueryBuilder getQuery(String queryText) { String lowerCaseQueryText = queryText.toLowerCase(Locale.ENGLISH); return prefixAndPartialQuery(lowerCaseQueryText, SORTABLE_ANALYZER.subField(FIELD_NAME), FIELD_NAME) .boost(3f); } },
@Override public Stream<QueryBuilder> getQueries(ComponentTextSearchQuery query) { List<String> tokens = query.getQueryTextTokens(); if (tokens.isEmpty()) { return Stream.empty(); } BoolQueryBuilder queryBuilder = boolQuery().boost(0.5f); tokens.stream() .map(text -> tokenQuery(text, query.getFieldName(), SEARCH_GRAMS_ANALYZER)) .forEach(queryBuilder::must); return Stream.of(queryBuilder); } },
@Override public Stream<QueryBuilder> getQueries(ComponentTextSearchQuery query) { List<String> tokens = query.getQueryTextTokens(); if (tokens.isEmpty()) { return Stream.empty(); } BoolQueryBuilder queryBuilder = prefixAndPartialQuery(tokens, query.getFieldName(), SEARCH_PREFIX_ANALYZER) .boost(3f); return Stream.of(queryBuilder); } },
@Override QueryBuilder getQuery(String queryText) { BoolQueryBuilder queryBuilder = boolQuery(); split(queryText) .map(text -> partialTermQuery(text, FIELD_NAME)) .forEach(queryBuilder::must); return queryBuilder .boost(0.5f); } },
private static QueryBuilder buildQuery(RuleQuery query) { // No contextual query case String queryText = query.getQueryText(); if (StringUtils.isEmpty(queryText)) { return matchAllQuery(); } // Build RuleBased contextual query BoolQueryBuilder qb = boolQuery(); String queryString = query.getQueryText(); if (queryString != null && !queryString.isEmpty()) { BoolQueryBuilder textQuery = boolQuery(); JavaTokenizer.split(queryString) .stream().map(token -> boolQuery().should( matchQuery( SEARCH_GRAMS_ANALYZER.subField(FIELD_RULE_NAME), StringUtils.left(token, DefaultIndexSettings.MAXIMUM_NGRAM_LENGTH)).boost(20f)) .should( matchPhraseQuery( ENGLISH_HTML_ANALYZER.subField(FIELD_RULE_HTML_DESCRIPTION), token).boost(3f))) .forEach(textQuery::must); qb.should(textQuery.boost(20f)); } // Match and partial Match queries // Search by key uses the "sortable" sub-field as it requires to be case-insensitive (lower-case filtering) qb.should(matchQuery(SORTABLE_ANALYZER.subField(FIELD_RULE_KEY), queryString).operator(Operator.AND).boost(30f)); qb.should(matchQuery(SORTABLE_ANALYZER.subField(FIELD_RULE_RULE_KEY), queryString).operator(Operator.AND).boost(15f)); qb.should(termQuery(FIELD_RULE_LANGUAGE, queryString, 3f)); return qb; }
@Override protected QueryBuilder doRewrite(QueryRewriteContext queryRewriteContext) throws IOException { BoolQueryBuilder newBuilder = new BoolQueryBuilder(); boolean changed = false; final int clauses = mustClauses.size() + mustNotClauses.size() + filterClauses.size() + shouldClauses.size(); if (clauses == 0) { return new MatchAllQueryBuilder().boost(boost()).queryName(queryName()); } changed |= rewriteClauses(queryRewriteContext, mustClauses, newBuilder::must); changed |= rewriteClauses(queryRewriteContext, mustNotClauses, newBuilder::mustNot); changed |= rewriteClauses(queryRewriteContext, filterClauses, newBuilder::filter); changed |= rewriteClauses(queryRewriteContext, shouldClauses, newBuilder::should); // lets do some early termination and prevent any kind of rewriting if we have a mandatory query that is a MatchNoneQueryBuilder Optional<QueryBuilder> any = Stream.concat(newBuilder.mustClauses.stream(), newBuilder.filterClauses.stream()) .filter(b -> b instanceof MatchNoneQueryBuilder).findAny(); if (any.isPresent()) { return any.get(); } if (changed) { newBuilder.adjustPureNegative = adjustPureNegative; newBuilder.minimumShouldMatch = minimumShouldMatch; newBuilder.boost(boost()); newBuilder.queryName(queryName()); return newBuilder; } return this; }
boolQuery.filter(queryBuilder); boolQuery.boost(boost); boolQuery.adjustPureNegative(adjustPureNegative); boolQuery.minimumShouldMatch(minimumShouldMatch);
@Override QueryBuilder getQuery(String queryText) { return prefixAndPartialQuery(queryText, FIELD_NAME, FIELD_NAME) .boost(2f); } },
@Override QueryBuilder getQuery(String queryText) { String lowerCaseQueryText = queryText.toLowerCase(Locale.ENGLISH); return prefixAndPartialQuery(lowerCaseQueryText, SORTABLE_ANALYZER.subField(FIELD_NAME), FIELD_NAME) .boost(3f); } },
@Override public Stream<QueryBuilder> getQueries(ComponentTextSearchQuery query) { List<String> tokens = query.getQueryTextTokens(); if (tokens.isEmpty()) { return Stream.empty(); } List<String> lowerCaseTokens = tokens.stream().map(t -> t.toLowerCase(Locale.ENGLISH)).collect(MoreCollectors.toList()); BoolQueryBuilder queryBuilder = prefixAndPartialQuery(lowerCaseTokens, query.getFieldName(), SEARCH_PREFIX_CASE_INSENSITIVE_ANALYZER) .boost(2f); return Stream.of(queryBuilder); } },
@Override public Stream<QueryBuilder> getQueries(ComponentTextSearchQuery query) { List<String> tokens = query.getQueryTextTokens(); if (tokens.isEmpty()) { return Stream.empty(); } BoolQueryBuilder queryBuilder = prefixAndPartialQuery(tokens, query.getFieldName(), SEARCH_PREFIX_ANALYZER) .boost(3f); return Stream.of(queryBuilder); } },
@Override public Stream<QueryBuilder> getQueries(ComponentTextSearchQuery query) { List<String> tokens = query.getQueryTextTokens(); if (tokens.isEmpty()) { return Stream.empty(); } BoolQueryBuilder queryBuilder = boolQuery().boost(0.5f); tokens.stream() .map(text -> tokenQuery(text, query.getFieldName(), SEARCH_GRAMS_ANALYZER)) .forEach(queryBuilder::must); return Stream.of(queryBuilder); } },
@Override QueryBuilder getQuery(String queryText) { BoolQueryBuilder queryBuilder = boolQuery(); split(queryText) .map(text -> partialTermQuery(text, FIELD_NAME)) .forEach(queryBuilder::must); return queryBuilder .boost(0.5f); } },
@Override protected QueryBuilder doRewrite(QueryRewriteContext queryRewriteContext) throws IOException { BoolQueryBuilder newBuilder = new BoolQueryBuilder(); boolean changed = false; final int clauses = mustClauses.size() + mustNotClauses.size() + filterClauses.size() + shouldClauses.size(); if (clauses == 0) { return new MatchAllQueryBuilder().boost(boost()).queryName(queryName()); } changed |= rewriteClauses(queryRewriteContext, mustClauses, newBuilder::must); changed |= rewriteClauses(queryRewriteContext, mustNotClauses, newBuilder::mustNot); changed |= rewriteClauses(queryRewriteContext, filterClauses, newBuilder::filter); changed |= rewriteClauses(queryRewriteContext, shouldClauses, newBuilder::should); // lets do some early termination and prevent any kind of rewriting if we have a mandatory query that is a MatchNoneQueryBuilder Optional<QueryBuilder> any = Stream.concat(newBuilder.mustClauses.stream(), newBuilder.filterClauses.stream()) .filter(b -> b instanceof MatchNoneQueryBuilder).findAny(); if (any.isPresent()) { return any.get(); } if (changed) { newBuilder.adjustPureNegative = adjustPureNegative; newBuilder.minimumShouldMatch = minimumShouldMatch; newBuilder.boost(boost()); newBuilder.queryName(queryName()); return newBuilder; } return this; }
@Override protected QueryBuilder doRewrite(QueryRewriteContext queryRewriteContext) throws IOException { BoolQueryBuilder newBuilder = new BoolQueryBuilder(); boolean changed = false; final int clauses = mustClauses.size() + mustNotClauses.size() + filterClauses.size() + shouldClauses.size(); if (clauses == 0) { return new MatchAllQueryBuilder().boost(boost()).queryName(queryName()); } changed |= rewriteClauses(queryRewriteContext, mustClauses, newBuilder::must); changed |= rewriteClauses(queryRewriteContext, mustNotClauses, newBuilder::mustNot); changed |= rewriteClauses(queryRewriteContext, filterClauses, newBuilder::filter); changed |= rewriteClauses(queryRewriteContext, shouldClauses, newBuilder::should); // lets do some early termination and prevent any kind of rewriting if we have a mandatory query that is a MatchNoneQueryBuilder Optional<QueryBuilder> any = Stream.concat(newBuilder.mustClauses.stream(), newBuilder.filterClauses.stream()) .filter(b -> b instanceof MatchNoneQueryBuilder).findAny(); if (any.isPresent()) { return any.get(); } if (changed) { newBuilder.adjustPureNegative = adjustPureNegative; newBuilder.minimumShouldMatch = minimumShouldMatch; newBuilder.boost(boost()); newBuilder.queryName(queryName()); return newBuilder; } return this; }
@Override protected QueryBuilder doRewrite(QueryRewriteContext queryRewriteContext) throws IOException { BoolQueryBuilder newBuilder = new BoolQueryBuilder(); boolean changed = false; final int clauses = mustClauses.size() + mustNotClauses.size() + filterClauses.size() + shouldClauses.size(); if (clauses == 0) { return new MatchAllQueryBuilder().boost(boost()).queryName(queryName()); } changed |= rewriteClauses(queryRewriteContext, mustClauses, newBuilder::must); changed |= rewriteClauses(queryRewriteContext, mustNotClauses, newBuilder::mustNot); changed |= rewriteClauses(queryRewriteContext, filterClauses, newBuilder::filter); changed |= rewriteClauses(queryRewriteContext, shouldClauses, newBuilder::should); if (changed) { newBuilder.adjustPureNegative = adjustPureNegative; newBuilder.disableCoord = disableCoord; newBuilder.minimumShouldMatch = minimumShouldMatch; newBuilder.boost(boost()); newBuilder.queryName(queryName()); return newBuilder; } return this; }
@Override public QueryBuilder createQuery() { if (Strings.isEmpty(value)) { if (ignoreNull) { return null; } return QueryBuilders.boolQuery() .mustNot(QueryBuilders.existsQuery(field)) .boost(boost); } return QueryBuilders.termQuery(field, value).boost(boost); }
private static QueryBuilder buildQuery(RuleQuery query) { // No contextual query case String queryText = query.getQueryText(); if (StringUtils.isEmpty(queryText)) { return matchAllQuery(); } // Build RuleBased contextual query BoolQueryBuilder qb = boolQuery(); String queryString = query.getQueryText(); if (queryString != null && !queryString.isEmpty()) { BoolQueryBuilder textQuery = boolQuery(); JavaTokenizer.split(queryString) .stream().map(token -> boolQuery().should( matchQuery( SEARCH_GRAMS_ANALYZER.subField(FIELD_RULE_NAME), StringUtils.left(token, DefaultIndexSettings.MAXIMUM_NGRAM_LENGTH)).boost(20f)) .should( matchPhraseQuery( ENGLISH_HTML_ANALYZER.subField(FIELD_RULE_HTML_DESCRIPTION), token).boost(3f))) .forEach(textQuery::must); qb.should(textQuery.boost(20f)); } // Match and partial Match queries // Search by key uses the "sortable" sub-field as it requires to be case-insensitive (lower-case filtering) qb.should(matchQuery(SORTABLE_ANALYZER.subField(FIELD_RULE_KEY), queryString).operator(Operator.AND).boost(30f)); qb.should(matchQuery(SORTABLE_ANALYZER.subField(FIELD_RULE_RULE_KEY), queryString).operator(Operator.AND).boost(15f)); qb.should(termQuery(FIELD_RULE_LANGUAGE, queryString, 3f)); return qb; }