Refine search
@Override protected SpanQuery doToQuery(QueryShardContext context) throws IOException { MappedFieldType mapper = context.fieldMapper(fieldName); Term term; if (mapper == null) { term = new Term(fieldName, BytesRefs.toBytesRef(value)); } else { Query termQuery = mapper.termQuery(value, context); term = MappedFieldType.extractTerm(termQuery); } return new SpanTermQuery(term); }
@Override public Spans getSpans(final LeafReaderContext context, Postings requiredPostings) throws IOException { assert termContext.wasBuiltFor(ReaderUtil.getTopLevelContext(context)) : "The top-reader used to create Weight is not the same as the current reader's top-reader (" + ReaderUtil.getTopLevelContext(context); final TermState state = termContext.get(context.ord); if (state == null) { // term is not present in that reader assert context.reader().docFreq(term) == 0 : "no termstate found but term exists in reader term=" + term; return null; } final Terms terms = context.reader().terms(term.field()); if (terms == null) return null; if (terms.hasPositions() == false) throw new IllegalStateException("field \"" + term.field() + "\" was indexed without position data; cannot run SpanTermQuery (term=" + term.text() + ")"); final TermsEnum termsEnum = terms.iterator(); termsEnum.seekExact(term.bytes(), state); final PostingsEnum postings = termsEnum.postings(null, requiredPostings.getRequiredPostings()); float positionsCost = termPositionsCost(termsEnum) * PHRASE_TO_SPAN_TERM_POSITIONS_COST; return new TermSpans(getSimScorer(context), postings, term, positionsCost); } }
/** * 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); } }
SpanTermQuery query = new SpanTermQuery(new Term(fieldName, valueBytes)); query.setBoost(boost); if (queryName != null) { parseContext.addNamedQuery(queryName, query);
int slop; int start; if (term.field().equals("lux_within")) { inOrder = true; slop = Integer.valueOf(term.text()); start = 1; else if (term.field().equals("lux_near")) { inOrder = false; slop = Integer.valueOf(term.text()); return new SpanNearQuery(clauses, slop, inOrder); return new SpanTermQuery(((TermQuery)q).getTerm());
assert terms.length > 0; if (terms.length == 1) { queryPos = new SpanTermQuery(terms[0]); } else { if (terms.length >= maxClauseCount) { orClauses[idx] = new SpanTermQuery(terms[idx]); return clauses.get(0); } else { return new SpanNearQuery(clauses.toArray(new SpanQuery[0]), 0, true);
protected void createWeights(String origQuery, SpanNearQuery parsedQuery, Map<String, Float> termWeights, Map<String, Float> bigramWeights, IndexReader reader) throws IOException { SpanQuery[] clauses = parsedQuery.getClauses(); //we need to recurse through the clauses until we get to SpanTermQuery Term lastTerm = null; Float lastWeight = null; for (int i = 0; i < clauses.length; i++) { SpanQuery clause = clauses[i]; if (clause instanceof SpanTermQuery) { Term term = ((SpanTermQuery) clause).getTerm(); Float weight = calculateWeight(term, reader); termWeights.put(term.text(), weight); if (lastTerm != null) {//calculate the bi-grams //use the smaller of the two weights if (lastWeight.floatValue() < weight.floatValue()) { bigramWeights.put(lastTerm + "," + term.text(), new Float(lastWeight.floatValue() * 0.25)); } else { bigramWeights.put(lastTerm + "," + term.text(), new Float(weight.floatValue() * 0.25)); } } //last lastTerm = term; lastWeight = weight; } else { //TODO: handle the other types throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Unhandled query type: " + clause.getClass().getName()); } } }
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 protected void addClause(List<SpanQuery> topLevel, Term term, int docFreq, float boost, TermContext states) { final SpanTermQuery q = new SpanTermQuery(term, states); topLevel.add(q); } };
SpanQuery[] clauses = new SpanQuery[phraseQueryTerms.length]; for (int i = 0; i < phraseQueryTerms.length; i++) { clauses[i] = new SpanTermQuery(phraseQueryTerms[i]); SpanNearQuery sp = new SpanNearQuery(clauses, slop, inorder); sp.setBoost(query.getBoost()); getPayloads(payloads, sp); } else if (query instanceof TermQuery) { SpanTermQuery stq = new SpanTermQuery(((TermQuery) query).getTerm()); stq.setBoost(query.getBoost()); getPayloads(payloads, stq); } else if (query instanceof SpanQuery) { disjuncts.add(new SpanTermQuery(termArray[j])); final boolean inorder = (slop == 0); SpanNearQuery sp = new SpanNearQuery(clauses, slop + positionGaps, inorder); sp.setBoost(query.getBoost());
public Term getTerm() { return query.getTerm(); }
Query q = new BoostingTermQuery(visitor.replaceTerm(((SpanTermQuery) query).getTerm())); q.setBoost(query.getBoost()); return q; Query q = new AllBoostingTermQuery(visitor.replaceTerm(((SpanTermQuery) query).getTerm())); q.setBoost(query.getBoost()); return q; Query q = new SpanTermQuery(visitor.replaceTerm(((SpanTermQuery) query).getTerm())); q.setBoost(query.getBoost()); return q;
@Override public boolean equals(Object obj) { if (this == obj) return true; if (obj instanceof BLSpanTermQuery) { BLSpanTermQuery other = (BLSpanTermQuery) obj; return query.equals(other.query); } return false; }