/** * Build the query */ public SpanNearQuery build() { return new SpanNearQuery(clauses.toArray(new SpanQuery[clauses.size()]), slop, ordered); }
/** * Creates a span query from the tokenstream. In the case of a single token, a simple <code>SpanTermQuery</code> is * returned. When multiple tokens, an ordered <code>SpanNearQuery</code> with slop 0 is returned. */ protected SpanQuery createSpanQuery(TokenStream in, String field) throws IOException { TermToBytesRefAttribute termAtt = in.getAttribute(TermToBytesRefAttribute.class); if (termAtt == null) { return null; } List<SpanTermQuery> terms = new ArrayList<>(); while (in.incrementToken()) { terms.add(new SpanTermQuery(new Term(field, termAtt.getBytesRef()))); } if (terms.isEmpty()) { return null; } else if (terms.size() == 1) { return terms.get(0); } else { return new SpanNearQuery(terms.toArray(new SpanTermQuery[0]), 0, true); } }
return clauses.get(0); } else { return new SpanNearQuery(clauses.toArray(new SpanQuery[0]), 0, true);
return Collections.singletonList(new SpanNearQuery(positionSpanQueries, mpq.getSlop() + positionGaps, inorder)); } else if (query instanceof CommonTermsQuery) {
private Query addSlopToSpan(SpanQuery query, int slop) { if (query instanceof SpanNearQuery) { return new SpanNearQuery(((SpanNearQuery) query).getClauses(), slop, ((SpanNearQuery) query).isInOrder()); } else if (query instanceof SpanOrQuery) { SpanQuery[] clauses = new SpanQuery[((SpanOrQuery) query).getClauses().length]; int pos = 0; for (SpanQuery clause : ((SpanOrQuery) query).getClauses()) { clauses[pos++] = (SpanQuery) addSlopToSpan(clause, slop); } return new SpanOrQuery(clauses); } else { return query; } }
/** * Build the query */ public SpanNearQuery build() { return new SpanNearQuery(clauses.toArray(new SpanQuery[clauses.size()]), slop, ordered); }
/** * Build the query */ public SpanNearQuery build() { return new SpanNearQuery(clauses.toArray(new SpanQuery[clauses.size()]), slop, ordered); }
/** * Build the query */ public SpanNearQuery build() { return new SpanNearQuery(clauses.toArray(new SpanQuery[clauses.size()]), slop, ordered); }
public SearchEngineQuery.SearchEngineSpanQuery toQuery() { SpanQuery[] spanQueries = values.toArray(new SpanQuery[values.size()]); SpanNearQuery spanNearQuery = new SpanNearQuery(spanQueries, slop, inOrder); return new LuceneSearchEngineQuery.LuceneSearchEngineSpanQuery(searchEngineFactory, spanNearQuery); }
@Override protected Query doToQuery(QueryShardContext context) throws IOException { SpanQuery[] spanQueries = new SpanQuery[clauses.size()]; for (int i = 0; i < clauses.size(); i++) { Query query = clauses.get(i).toQuery(context); assert query instanceof SpanQuery; spanQueries[i] = (SpanQuery) query; } return new SpanNearQuery(spanQueries, slop, inOrder); }
@Override protected Query doToQuery(QueryShardContext context) throws IOException { SpanQuery[] spanQueries = new SpanQuery[clauses.size()]; for (int i = 0; i < clauses.size(); i++) { Query query = clauses.get(i).toQuery(context); assert query instanceof SpanQuery; spanQueries[i] = (SpanQuery) query; } return new SpanNearQuery(spanQueries, slop, inOrder); }
private Query toSpanQueryPrefix(SpanQuery query, float boost) { if (query instanceof SpanTermQuery) { SpanMultiTermQueryWrapper<PrefixQuery> ret = new SpanMultiTermQueryWrapper<>(new PrefixQuery(((SpanTermQuery) query).getTerm())); return boost == 1 ? ret : new BoostQuery(ret, boost); } else if (query instanceof SpanNearQuery) { SpanNearQuery spanNearQuery = (SpanNearQuery) query; SpanQuery[] clauses = spanNearQuery.getClauses(); if (clauses[clauses.length - 1] instanceof SpanTermQuery) { clauses[clauses.length - 1] = new SpanMultiTermQueryWrapper<>( new PrefixQuery(((SpanTermQuery) clauses[clauses.length - 1]).getTerm()) ); } SpanNearQuery newQuery = new SpanNearQuery(clauses, spanNearQuery.getSlop(), spanNearQuery.isInOrder()); return boost == 1 ? newQuery : new BoostQuery(newQuery, boost); } else if (query instanceof SpanOrQuery) { SpanOrQuery orQuery = (SpanOrQuery) query; SpanQuery[] clauses = new SpanQuery[orQuery.getClauses().length]; for (int i = 0; i < clauses.length; i++) { clauses[i] = (SpanQuery) toSpanQueryPrefix(orQuery.getClauses()[i], 1); } return boost == 1 ? new SpanOrQuery(clauses) : new BoostQuery(new SpanOrQuery(clauses), boost); } else { return query; } }
@Override public SpanQuery getSpanQuery(Element e) throws ParserException { String slopString = DOMUtils.getAttributeOrFail(e, "slop"); int slop = Integer.parseInt(slopString); boolean inOrder = DOMUtils.getAttribute(e, "inOrder", false); List<SpanQuery> spans = new ArrayList<>(); for (Node kid = e.getFirstChild(); kid != null; kid = kid.getNextSibling()) { if (kid.getNodeType() == Node.ELEMENT_NODE) { spans.add(factory.getSpanQuery((Element) kid)); } } SpanQuery[] spanQueries = spans.toArray(new SpanQuery[spans.size()]); SpanQuery snq = new SpanNearQuery(spanQueries, slop, inOrder); float boost = DOMUtils.getAttribute(e, "boost", 1.0f); return new SpanBoostQuery(snq, boost); }
private static Query[] getPrebuiltQueries(String field) { // be wary of unanalyzed text return new Query[] { new SpanFirstQuery(new SpanTermQuery(new Term(field, "ford")), 5), new SpanNearQuery(new SpanQuery[]{new SpanTermQuery(new Term(field, "night")), new SpanTermQuery(new Term(field, "trading"))}, 4, false), new SpanNearQuery(new SpanQuery[]{new SpanFirstQuery(new SpanTermQuery(new Term(field, "ford")), 10), new SpanTermQuery(new Term(field, "credit"))}, 10, false), new WildcardQuery(new Term(field, "fo*")), }; }
@Override public SpanQuery getSpanQuery(Element e) throws ParserException { String slopString = DOMUtils.getAttributeOrFail(e, "slop"); int slop = Integer.parseInt(slopString); boolean inOrder = DOMUtils.getAttribute(e, "inOrder", false); List<SpanQuery> spans = new ArrayList<>(); for (Node kid = e.getFirstChild(); kid != null; kid = kid.getNextSibling()) { if (kid.getNodeType() == Node.ELEMENT_NODE) { spans.add(factory.getSpanQuery((Element) kid)); } } SpanQuery[] spanQueries = spans.toArray(new SpanQuery[spans.size()]); SpanQuery snq = new SpanNearQuery(spanQueries, slop, inOrder); float boost = DOMUtils.getAttribute(e, "boost", 1.0f); return new SpanBoostQuery(snq, boost); }
private static Query[] getPrebuiltQueries(String field) { WildcardQuery wcq = new WildcardQuery(new Term(field, "fo*")); wcq .setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE); // be wary of unanalyzed text return new Query[] { new SpanFirstQuery(new SpanTermQuery(new Term(field, "ford")), 5), new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term(field, "night")), new SpanTermQuery(new Term(field, "trading")) }, 4, false), new SpanNearQuery(new SpanQuery[] { new SpanFirstQuery(new SpanTermQuery(new Term(field, "ford")), 10), new SpanTermQuery(new Term(field, "credit")) }, 10, false), wcq, }; }
private Query addSlopToSpan(SpanQuery query, int slop) { if (query instanceof SpanNearQuery) { return new SpanNearQuery(((SpanNearQuery) query).getClauses(), slop, ((SpanNearQuery) query).isInOrder()); } else if (query instanceof SpanOrQuery) { SpanQuery[] clauses = new SpanQuery[((SpanOrQuery) query).getClauses().length]; int pos = 0; for (SpanQuery clause : ((SpanOrQuery) query).getClauses()) { clauses[pos++] = (SpanQuery) addSlopToSpan(clause, slop); } return new SpanOrQuery(clauses); } else { return query; } }
private Query addSlopToSpan(SpanQuery query, int slop) { if (query instanceof SpanNearQuery) { return new SpanNearQuery(((SpanNearQuery) query).getClauses(), slop, ((SpanNearQuery) query).isInOrder()); } else if (query instanceof SpanOrQuery) { SpanQuery[] clauses = new SpanQuery[((SpanOrQuery) query).getClauses().length]; int pos = 0; for (SpanQuery clause : ((SpanOrQuery) query).getClauses()) { clauses[pos++] = (SpanQuery) addSlopToSpan(clause, slop); } return new SpanOrQuery(clauses); } else { return query; } }
protected Query rewritePhraseQuery(PhraseQuery query) throws RewriteException { Term[] terms = query.getTerms(); int[] positions = query.getPositions(); SpanTermQuery[] spanQueries = new SpanTermQuery[positions.length]; for(int i = 0; i < positions.length; i++) { if(positions[i] - positions[0] != i) { // positions must increase by 1 each time (i-1 is safe as the if can't be true for i=0) throw new RewriteException("Don't know how to rewrite PhraseQuery with holes or overlaps " + "(position must increase by 1 each time but found term " + terms[i-1] + " at position " + positions[i-1] + " followed by term " + terms[i] + " at position " + positions[i] + ")", query); } spanQueries[i] = new SpanTermQuery(terms[i]); } return forceOffsets(new SpanNearQuery(spanQueries, query.getSlop(), true)); }
private Query addSlopToSpan(SpanQuery query, int slop) { if (query instanceof SpanNearQuery) { return new SpanNearQuery(((SpanNearQuery) query).getClauses(), slop, ((SpanNearQuery) query).isInOrder()); } else if (query instanceof SpanOrQuery) { SpanQuery[] clauses = new SpanQuery[((SpanOrQuery) query).getClauses().length]; int pos = 0; for (SpanQuery clause : ((SpanOrQuery) query).getClauses()) { clauses[pos++] = (SpanQuery) addSlopToSpan(clause, slop); } return new SpanOrQuery(clauses); } else { return query; } }