Map with <@link WeightedSpanTerm>s using the terms from the supplied Query.
- *
- * @param query
- * Query to extract Terms from
- * @param terms
- * Map to place created WeightedSpanTerms in
- * @throws IOException
- */
- private void extract(Query query, Map terms) throws IOException {
- if (query instanceof BooleanQuery) {
- BooleanClause[] queryClauses = ((BooleanQuery) query).getClauses();
+ /**
+ * Fills a Map with <@link WeightedSpanTerm>s using the terms
+ * from the supplied Query.
+ *
+ * @param query
+ * Query to extract Terms from
+ * @param terms
+ * Map to place created WeightedSpanTerms in
+ * @throws IOException
+ */
+ private void extract(Query query, Map terms) throws IOException {
+ if (query instanceof BooleanQuery) {
+ BooleanClause[] queryClauses = ((BooleanQuery) query).getClauses();
- for (int i = 0; i < queryClauses.length; i++) {
- if (!queryClauses[i].isProhibited()) {
- extract(queryClauses[i].getQuery(), terms);
- }
- }
- } else if (query instanceof PhraseQuery) {
- PhraseQuery phraseQuery = ((PhraseQuery) query);
- Term[] phraseQueryTerms = phraseQuery.getTerms();
- SpanQuery[] clauses = new SpanQuery[phraseQueryTerms.length];
- for (int i = 0; i < phraseQueryTerms.length; i++) {
- clauses[i] = new SpanTermQuery(phraseQueryTerms[i]);
- }
- int slop = phraseQuery.getSlop();
- int[] positions = phraseQuery.getPositions();
- // add largest position increment to slop
- if (positions.length > 0) {
- int lastPos = positions[0];
- int largestInc = 0;
- int sz = positions.length;
- for (int i = 1; i < sz; i++) {
- int pos = positions[i];
- int inc = pos - lastPos;
- if (inc > largestInc) {
- largestInc = inc;
- }
- lastPos = pos;
- }
- if(largestInc > 1) {
- slop += largestInc;
- }
- }
+ for (int i = 0; i < queryClauses.length; i++) {
+ if (!queryClauses[i].isProhibited()) {
+ extract(queryClauses[i].getQuery(), terms);
+ }
+ }
+ } else if (query instanceof PhraseQuery) {
+ PhraseQuery phraseQuery = ((PhraseQuery) query);
+ Term[] phraseQueryTerms = phraseQuery.getTerms();
+ SpanQuery[] clauses = new SpanQuery[phraseQueryTerms.length];
+ for (int i = 0; i < phraseQueryTerms.length; i++) {
+ clauses[i] = new SpanTermQuery(phraseQueryTerms[i]);
+ }
+ int slop = phraseQuery.getSlop();
+ int[] positions = phraseQuery.getPositions();
+ // add largest position increment to slop
+ if (positions.length > 0) {
+ int lastPos = positions[0];
+ int largestInc = 0;
+ int sz = positions.length;
+ for (int i = 1; i < sz; i++) {
+ int pos = positions[i];
+ int inc = pos - lastPos;
+ if (inc > largestInc) {
+ largestInc = inc;
+ }
+ lastPos = pos;
+ }
+ if (largestInc > 1) {
+ slop += largestInc;
+ }
+ }
- boolean inorder = false;
+ boolean inorder = false;
- if (slop == 0) {
- inorder = true;
- }
+ if (slop == 0) {
+ inorder = true;
+ }
- SpanNearQuery sp = new SpanNearQuery(clauses, slop, inorder);
- sp.setBoost(query.getBoost());
- extractWeightedSpanTerms(terms, sp);
- } else if (query instanceof TermQuery) {
- extractWeightedTerms(terms, query);
- } else if (query instanceof SpanQuery) {
- extractWeightedSpanTerms(terms, (SpanQuery) query);
- } else if (query instanceof FilteredQuery) {
- extract(((FilteredQuery) query).getQuery(), terms);
- } else if (query instanceof DisjunctionMaxQuery) {
- for (Iterator iterator = ((DisjunctionMaxQuery) query).iterator(); iterator.hasNext();) {
- extract((Query) iterator.next(), terms);
- }
- } else if (query instanceof MultiTermQuery && expandMultiTermQuery) {
- MultiTermQuery mtq = ((MultiTermQuery)query);
- if(mtq.getRewriteMethod() != MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE) {
- mtq = copyMultiTermQuery(mtq);
- mtq.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
- query = mtq;
- }
- String field = null;
- if(mtq instanceof TermRangeQuery) {
- field = ((TermRangeQuery)mtq).getField();
- } else {
- Term term = mtq.getTerm();
- if(term != null) {
- field = term.field();
- }
- }
- if(field != null) {
- IndexReader ir = getReaderForField(field);
- extract(query.rewrite(ir), terms);
- }
- } else if (query instanceof RangeQuery) {
- String field = ((RangeQuery)query).getField();
- IndexReader ir = getReaderForField(field);
- extract(query.rewrite(ir), terms);
- } else if (query instanceof MultiPhraseQuery) {
- final MultiPhraseQuery mpq = (MultiPhraseQuery) query;
- final List termArrays = mpq.getTermArrays();
- final int[] positions = mpq.getPositions();
- if (positions.length > 0) {
+ SpanNearQuery sp = new SpanNearQuery(clauses, slop, inorder);
+ sp.setBoost(query.getBoost());
+ extractWeightedSpanTerms(terms, sp);
+ } else if (query instanceof TermQuery) {
+ extractWeightedTerms(terms, query);
+ } else if (query instanceof SpanQuery) {
+ extractWeightedSpanTerms(terms, (SpanQuery) query);
+ } else if (query instanceof FilteredQuery) {
+ extract(((FilteredQuery) query).getQuery(), terms);
+ } else if (query instanceof DisjunctionMaxQuery) {
+ for (Iterator iterator = ((DisjunctionMaxQuery) query).iterator(); iterator
+ .hasNext();) {
+ extract((Query) iterator.next(), terms);
+ }
+ } else if (query instanceof MultiTermQuery && expandMultiTermQuery) {
+ MultiTermQuery mtq = ((MultiTermQuery) query);
+ if (mtq.getRewriteMethod() != MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE) {
+ mtq = copyMultiTermQuery(mtq);
+ mtq
+ .setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
+ query = mtq;
+ }
+ String field = null;
+ if (mtq instanceof TermRangeQuery) {
+ field = ((TermRangeQuery) mtq).getField();
+ } else {
+ Term term = mtq.getTerm();
+ if (term != null) {
+ field = term.field();
+ }
+ }
+ if (field != null) {
+ IndexReader ir = getReaderForField(field);
+ extract(query.rewrite(ir), terms);
+ }
+ } else if (query instanceof RangeQuery) {
+ String field = ((RangeQuery) query).getField();
+ IndexReader ir = getReaderForField(field);
+ extract(query.rewrite(ir), terms);
+ } else if (query instanceof MultiPhraseQuery) {
+ final MultiPhraseQuery mpq = (MultiPhraseQuery) query;
+ final List termArrays = mpq.getTermArrays();
+ final int[] positions = mpq.getPositions();
+ if (positions.length > 0) {
- int maxPosition = positions[positions.length - 1];
- for (int i = 0; i < positions.length - 1; ++i) {
- if (positions[i] > maxPosition) {
- maxPosition = positions[i];
- }
- }
+ int maxPosition = positions[positions.length - 1];
+ for (int i = 0; i < positions.length - 1; ++i) {
+ if (positions[i] > maxPosition) {
+ maxPosition = positions[i];
+ }
+ }
- final List[] disjunctLists = new List[maxPosition + 1];
- int distinctPositions = 0;
+ final List[] disjunctLists = new List[maxPosition + 1];
+ int distinctPositions = 0;
- for (int i = 0; i < termArrays.size(); ++i) {
- final Term[] termArray = (Term[]) termArrays.get(i);
- List disjuncts = disjunctLists[positions[i]];
- if (disjuncts == null) {
- disjuncts = (disjunctLists[positions[i]] = new ArrayList(termArray.length));
- ++distinctPositions;
- }
- for (int j = 0; j < termArray.length; ++j) {
- disjuncts.add(new SpanTermQuery(termArray[j]));
- }
- }
+ for (int i = 0; i < termArrays.size(); ++i) {
+ final Term[] termArray = (Term[]) termArrays.get(i);
+ List disjuncts = disjunctLists[positions[i]];
+ if (disjuncts == null) {
+ disjuncts = (disjunctLists[positions[i]] = new ArrayList(
+ termArray.length));
+ ++distinctPositions;
+ }
+ for (int j = 0; j < termArray.length; ++j) {
+ disjuncts.add(new SpanTermQuery(termArray[j]));
+ }
+ }
- int positionGaps = 0;
- int position = 0;
- final SpanQuery[] clauses = new SpanQuery[distinctPositions];
- for (int i = 0; i < disjunctLists.length; ++i) {
- List disjuncts = disjunctLists[i];
- if (disjuncts != null) {
- clauses[position++] = new SpanOrQuery((SpanQuery[]) disjuncts
- .toArray(new SpanQuery[disjuncts.size()]));
- } else {
- ++positionGaps;
- }
- }
+ int positionGaps = 0;
+ int position = 0;
+ final SpanQuery[] clauses = new SpanQuery[distinctPositions];
+ for (int i = 0; i < disjunctLists.length; ++i) {
+ List disjuncts = disjunctLists[i];
+ if (disjuncts != null) {
+ clauses[position++] = new SpanOrQuery(
+ (SpanQuery[]) disjuncts
+ .toArray(new SpanQuery[disjuncts.size()]));
+ } else {
+ ++positionGaps;
+ }
+ }
- final int slop = mpq.getSlop();
- final boolean inorder = (slop == 0);
+ final int slop = mpq.getSlop();
+ final boolean inorder = (slop == 0);
- SpanNearQuery sp = new SpanNearQuery(clauses, slop + positionGaps, inorder);
- sp.setBoost(query.getBoost());
- extractWeightedSpanTerms(terms, sp);
- }
- }
- }
+ SpanNearQuery sp = new SpanNearQuery(clauses, slop
+ + positionGaps, inorder);
+ sp.setBoost(query.getBoost());
+ extractWeightedSpanTerms(terms, sp);
+ }
+ }
+ }
- /**
- * Fills a Map with <@link WeightedSpanTerm>s using the terms from the supplied SpanQuery.
- *
- * @param terms
- * Map to place created WeightedSpanTerms in
- * @param spanQuery
- * SpanQuery to extract Terms from
- * @throws IOException
- */
- private void extractWeightedSpanTerms(Map terms, SpanQuery spanQuery) throws IOException {
- Set fieldNames;
-
- if (fieldName == null) {
- fieldNames = new HashSet();
- collectSpanQueryFields(spanQuery, fieldNames);
- } else {
- fieldNames = new HashSet(1);
- fieldNames.add(fieldName);
- }
- // To support the use of the default field name
- if (defaultField != null) {
- fieldNames.add(defaultField);
- }
-
+ /**
+ * Fills a Map with <@link WeightedSpanTerm>s using the terms
+ * from the supplied SpanQuery.
+ *
+ * @param terms
+ * Map to place created WeightedSpanTerms in
+ * @param spanQuery
+ * SpanQuery to extract Terms from
+ * @throws IOException
+ */
+ private void extractWeightedSpanTerms(
+ Map/* Map with <@link WeightedSpanTerm>s using the terms from the supplied Query.
- *
- * @param terms
- * Map to place created WeightedSpanTerms in
- * @param query
- * Query to extract Terms from
- * @throws IOException
- */
- private void extractWeightedTerms(Map terms, Query query) throws IOException {
- Set nonWeightedTerms = new HashSet();
- query.extractTerms(nonWeightedTerms);
+ if (weightedSpanTerm == null) {
+ weightedSpanTerm = new WeightedSpanTerm(spanQuery
+ .getBoost(), queryTerm.text());
+ // MIKE: Only add here if valid
+ Iterator spanPosIter = spanPositions.iterator();
+ List/* defaultField
- */
- private boolean fieldNameComparator(String fieldNameToCheck) {
- boolean rv = fieldName == null || fieldNameToCheck == fieldName
- || fieldNameToCheck == defaultField;
- return rv;
- }
+ /**
+ * Fills a Map with <@link WeightedSpanTerm>s using the terms
+ * from the supplied Query.
+ *
+ * @param terms
+ * Map to place created WeightedSpanTerms in
+ * @param query
+ * Query to extract Terms from
+ * @throws IOException
+ */
+ private void extractWeightedTerms(Map terms, Query query)
+ throws IOException {
+ Set nonWeightedTerms = new HashSet();
+ query.extractTerms(nonWeightedTerms);
- private IndexReader getReaderForField(String field) throws IOException {
- if(wrapToCaching && !cachedTokenStream && !(tokenStream instanceof CachingTokenFilter)) {
- tokenStream = new CachingTokenFilter(tokenStream);
- cachedTokenStream = true;
- }
- IndexReader reader = (IndexReader) readers.get(field);
- if (reader == null) {
- MemoryIndex indexer = new MemoryIndex();
- indexer.addField(field, tokenStream);
- tokenStream.reset();
- IndexSearcher searcher = indexer.createSearcher();
- reader = searcher.getIndexReader();
- readers.put(field, reader);
- }
+ for (Iterator iter = nonWeightedTerms.iterator(); iter.hasNext();) {
+ Term queryTerm = (Term) iter.next();
- return reader;
- }
+ if (fieldNameComparator(queryTerm.field())) {
+ WeightedSpanTerm weightedSpanTerm = new WeightedSpanTerm(query
+ .getBoost(), queryTerm.text());
+ terms.put(queryTerm.text(), weightedSpanTerm);
+ }
+ }
+ }
- /**
- * Creates a Map of WeightedSpanTerms from the given Query and TokenStream.
- *
- *
- *
- * @param query
- * that caused hit
- * @param tokenStream
- * of text to be highlighted
- * @return Map containing WeightedSpanTerms
- * @throws IOException
- */
- public Map getWeightedSpanTerms(Query query, TokenStream tokenStream)
- throws IOException {
- return getWeightedSpanTerms(query, tokenStream, null);
- }
+ /**
+ * Necessary to implement matches for queries against
+ * defaultField
+ */
+ private boolean fieldNameComparator(String fieldNameToCheck) {
+ boolean rv = fieldName == null || fieldNameToCheck == fieldName
+ || fieldNameToCheck == defaultField;
+ return rv;
+ }
- /**
- * Creates a Map of WeightedSpanTerms from the given Query and TokenStream.
- *
- *
- *
- * @param query
- * that caused hit
- * @param tokenStream
- * of text to be highlighted
- * @param fieldName
- * restricts Term's used based on field name
- * @return Map containing WeightedSpanTerms
- * @throws IOException
- */
- public Map getWeightedSpanTerms(Query query, TokenStream tokenStream,
- String fieldName) throws IOException {
- if (fieldName != null) {
- this.fieldName = StringHelper.intern(fieldName);
- } else {
- this.fieldName = null;
- }
+ private IndexReader getReaderForField(String field) throws IOException {
+ if (wrapToCaching && !cachedTokenStream
+ && !(tokenStream instanceof CachingTokenFilter)) {
+ tokenStream = new CachingTokenFilter(tokenStream);
+ cachedTokenStream = true;
+ }
+ IndexReader reader = (IndexReader) readers.get(field);
+ if (reader == null) {
+ MemoryIndex indexer = new MemoryIndex();
+ indexer.addField(field, tokenStream);
+ tokenStream.reset();
+ IndexSearcher searcher = indexer.createSearcher();
+ reader = searcher.getIndexReader();
+ readers.put(field, reader);
+ }
- Map terms = new PositionCheckingMap();
- this.tokenStream = tokenStream;
- try {
- extract(query, terms);
- } finally {
- closeReaders();
- }
+ return reader;
+ }
- return terms;
- }
+ /**
+ * Creates a Map of WeightedSpanTerms from the given
+ * Query and TokenStream.
+ *
+ *
+ *
+ * @param query
+ * that caused hit
+ * @param tokenStream
+ * of text to be highlighted
+ * @return Map containing WeightedSpanTerms
+ * @throws IOException
+ */
+ public Map getWeightedSpanTerms(Query query, TokenStream tokenStream)
+ throws IOException {
+ return getWeightedSpanTerms(query, tokenStream, null);
+ }
- /**
- * Creates a Map of WeightedSpanTerms from the given Query and TokenStream. Uses a supplied
- * IndexReader to properly weight terms (for gradient highlighting).
- *
- *
- *
- * @param query
- * that caused hit
- * @param tokenStream
- * of text to be highlighted
- * @param fieldName
- * restricts Term's used based on field name
- * @param reader
- * to use for scoring
- * @return Map of WeightedSpanTerms with quasi tf/idf scores
- * @throws IOException
- */
- public Map getWeightedSpanTermsWithScores(Query query, TokenStream tokenStream, String fieldName,
- IndexReader reader) throws IOException {
- if (fieldName != null) {
- this.fieldName = StringHelper.intern(fieldName);
- } else {
- this.fieldName = null;
- }
- this.tokenStream = tokenStream;
+ /**
+ * Creates a Map of WeightedSpanTerms from the given
+ * Query and TokenStream.
+ *
+ *
+ *
+ * @param query
+ * that caused hit
+ * @param tokenStream
+ * of text to be highlighted
+ * @param fieldName
+ * restricts Term's used based on field name
+ * @return Map containing WeightedSpanTerms
+ * @throws IOException
+ */
+ public Map getWeightedSpanTerms(Query query, TokenStream tokenStream,
+ String fieldName) throws IOException {
+ if (fieldName != null) {
+ this.fieldName = StringHelper.intern(fieldName);
+ } else {
+ this.fieldName = null;
+ }
- Map terms = new PositionCheckingMap();
- extract(query, terms);
+ Map terms = new PositionCheckingMap();
+ this.tokenStream = tokenStream;
+ try {
+ extract(query, terms);
+ } finally {
+ closeReaders();
+ }
- int totalNumDocs = reader.numDocs();
- Set weightedTerms = terms.keySet();
- Iterator it = weightedTerms.iterator();
+ return terms;
+ }
- try {
- while (it.hasNext()) {
- WeightedSpanTerm weightedSpanTerm = (WeightedSpanTerm) terms.get(it.next());
- int docFreq = reader.docFreq(new Term(fieldName, weightedSpanTerm.term));
- // docFreq counts deletes
- if(totalNumDocs < docFreq) {
- docFreq = totalNumDocs;
- }
- // IDF algorithm taken from DefaultSimilarity class
- float idf = (float) (Math.log((float) totalNumDocs / (double) (docFreq + 1)) + 1.0);
- weightedSpanTerm.weight *= idf;
- }
- } finally {
+ /**
+ * Creates a Map of WeightedSpanTerms from the given
+ * Query and TokenStream. Uses a supplied
+ * IndexReader to properly weight terms (for gradient
+ * highlighting).
+ *
+ *
+ *
+ * @param query
+ * that caused hit
+ * @param tokenStream
+ * of text to be highlighted
+ * @param fieldName
+ * restricts Term's used based on field name
+ * @param reader
+ * to use for scoring
+ * @return Map of WeightedSpanTerms with quasi tf/idf scores
+ * @throws IOException
+ */
+ public Map getWeightedSpanTermsWithScores(Query query,
+ TokenStream tokenStream, String fieldName, IndexReader reader)
+ throws IOException {
+ if (fieldName != null) {
+ this.fieldName = StringHelper.intern(fieldName);
+ } else {
+ this.fieldName = null;
+ }
+ this.tokenStream = tokenStream;
- closeReaders();
- }
+ Map terms = new PositionCheckingMap();
+ extract(query, terms);
- return terms;
- }
-
+ int totalNumDocs = reader.numDocs();
+ Set weightedTerms = terms.keySet();
+ Iterator it = weightedTerms.iterator();
- private void collectSpanQueryFields(SpanQuery spanQuery, Set fieldNames) {
- if (spanQuery instanceof FieldMaskingSpanQuery) {
- collectSpanQueryFields(((FieldMaskingSpanQuery)spanQuery).getMaskedQuery(), fieldNames);
- } else if (spanQuery instanceof SpanFirstQuery) {
- collectSpanQueryFields(((SpanFirstQuery)spanQuery).getMatch(), fieldNames);
- } else if (spanQuery instanceof SpanNearQuery) {
- SpanQuery[] clauses = ((SpanNearQuery)spanQuery).getClauses();
- for(int i = 0; i < clauses.length; i++) {
- collectSpanQueryFields(clauses[i], fieldNames);
- }
- } else if (spanQuery instanceof SpanNotQuery) {
- collectSpanQueryFields(((SpanNotQuery)spanQuery).getInclude(), fieldNames);
- } else if (spanQuery instanceof SpanOrQuery) {
- SpanQuery[] clauses = ((SpanOrQuery)spanQuery).getClauses();
- for(int i = 0; i < clauses.length; i++) {
- collectSpanQueryFields(clauses[i], fieldNames);
- }
- } else {
- fieldNames.add(spanQuery.getField());
- }
- }
-
- private boolean mustRewriteQuery(SpanQuery spanQuery) {
- if (!expandMultiTermQuery) {
- return false; // Will throw UnsupportedOperationException in case of a SpanRegexQuery.
- } else if (spanQuery instanceof FieldMaskingSpanQuery) {
- return mustRewriteQuery(((FieldMaskingSpanQuery)spanQuery).getMaskedQuery());
- } else if (spanQuery instanceof SpanFirstQuery) {
- return mustRewriteQuery(((SpanFirstQuery)spanQuery).getMatch());
- } else if (spanQuery instanceof SpanNearQuery) {
- SpanQuery[] clauses = ((SpanNearQuery)spanQuery).getClauses();
- for(int i = 0; i < clauses.length; i++) {
- if (mustRewriteQuery(clauses[i])) {
- return true;
- }
- }
- return false;
- } else if (spanQuery instanceof SpanNotQuery) {
- SpanNotQuery spanNotQuery = (SpanNotQuery)spanQuery;
- return mustRewriteQuery(spanNotQuery.getInclude()) || mustRewriteQuery(spanNotQuery.getExclude());
- } else if (spanQuery instanceof SpanOrQuery) {
- SpanQuery[] clauses = ((SpanOrQuery)spanQuery).getClauses();
- for(int i = 0; i < clauses.length; i++) {
- if (mustRewriteQuery(clauses[i])) {
- return true;
- }
- }
- return false;
- } else if (spanQuery instanceof SpanTermQuery) {
- return false;
- } else {
- return true;
- }
- }
-
-
- /**
- * This class makes sure that if both position sensitive and insensitive
- * versions of the same term are added, the position insensitive one wins.
- */
- static private class PositionCheckingMap extends HashMap {
+ try {
+ while (it.hasNext()) {
+ WeightedSpanTerm weightedSpanTerm = (WeightedSpanTerm) terms
+ .get(it.next());
+ int docFreq = reader.docFreq(new Term(fieldName,
+ weightedSpanTerm.term));
+ // docFreq counts deletes
+ if (totalNumDocs < docFreq) {
+ docFreq = totalNumDocs;
+ }
+ // IDF algorithm taken from DefaultSimilarity class
+ float idf = (float) (Math.log((float) totalNumDocs
+ / (double) (docFreq + 1)) + 1.0);
+ weightedSpanTerm.weight *= idf;
+ }
+ } finally {
- public void putAll(Map m) {
- Iterator it = m.entrySet().iterator();
- while (it.hasNext()) {
- Map.Entry entry = (java.util.Map.Entry) it.next();
- this.put(entry.getKey(), entry.getValue());
- }
- }
+ closeReaders();
+ }
- public Object put(Object key, Object value) {
- Object prev = super.put(key, value);
- if (prev == null) return prev;
- WeightedSpanTerm prevTerm = (WeightedSpanTerm)prev;
- WeightedSpanTerm newTerm = (WeightedSpanTerm)value;
- if (!prevTerm.positionSensitive) {
- newTerm.positionSensitive = false;
- }
- return prev;
- }
-
- }
-
- private MultiTermQuery copyMultiTermQuery(MultiTermQuery query) {
- if(query instanceof TermRangeQuery) {
- TermRangeQuery q = (TermRangeQuery)query;
- q.setBoost(query.getBoost());
- return new TermRangeQuery(q.getField(), q.getLowerTerm(), q.getUpperTerm(), q.includesLower(), q.includesUpper());
- } else if(query instanceof WildcardQuery) {
- MultiTermQuery q = new WildcardQuery(query.getTerm());
- q.setBoost(query.getBoost());
- return q;
- } else if(query instanceof PrefixQuery) {
- MultiTermQuery q = new PrefixQuery(query.getTerm());
- q.setBoost(q.getBoost());
- return q;
- } else if(query instanceof FuzzyQuery) {
- FuzzyQuery q = (FuzzyQuery)query;
- q.setBoost(q.getBoost());
- return new FuzzyQuery(q.getTerm(), q.getMinSimilarity(), q.getPrefixLength());
- }
-
- return query;
- }
-
-
- public boolean getExpandMultiTermQuery() {
- return expandMultiTermQuery;
- }
+ return terms;
+ }
- public void setExpandMultiTermQuery(boolean expandMultiTermQuery) {
- this.expandMultiTermQuery = expandMultiTermQuery;
- }
-
- public boolean isCachedTokenStream() {
- return cachedTokenStream;
- }
-
- public TokenStream getTokenStream() {
- return tokenStream;
- }
-
- /**
- * By default, {@link TokenStream}s that are not of the type
- * {@link CachingTokenFilter} are wrapped in a {@link CachingTokenFilter} to
- * ensure an efficient reset - if you are already using a different caching
- * {@link TokenStream} impl and you don't want it to be wrapped, set this to
- * false.
- *
- * @param wrap
- */
- public void setWrapIfNotCachingTokenFilter(boolean wrap) {
- this.wrapToCaching = wrap;
- }
+ private void collectSpanQueryFields(SpanQuery spanQuery, Set fieldNames) {
+ if (spanQuery instanceof FieldMaskingSpanQuery) {
+ collectSpanQueryFields(((FieldMaskingSpanQuery) spanQuery)
+ .getMaskedQuery(), fieldNames);
+ } else if (spanQuery instanceof SpanFirstQuery) {
+ collectSpanQueryFields(((SpanFirstQuery) spanQuery).getMatch(),
+ fieldNames);
+ } else if (spanQuery instanceof SpanNearQuery) {
+ SpanQuery[] clauses = ((SpanNearQuery) spanQuery).getClauses();
+ for (int i = 0; i < clauses.length; i++) {
+ collectSpanQueryFields(clauses[i], fieldNames);
+ }
+ } else if (spanQuery instanceof SpanNotQuery) {
+ collectSpanQueryFields(((SpanNotQuery) spanQuery).getInclude(),
+ fieldNames);
+ } else if (spanQuery instanceof SpanOrQuery) {
+ SpanQuery[] clauses = ((SpanOrQuery) spanQuery).getClauses();
+ for (int i = 0; i < clauses.length; i++) {
+ collectSpanQueryFields(clauses[i], fieldNames);
+ }
+ } else {
+ fieldNames.add(spanQuery.getField());
+ }
+ }
+
+ private boolean mustRewriteQuery(SpanQuery spanQuery) {
+ if (!expandMultiTermQuery) {
+ return false; // Will throw UnsupportedOperationException in case of
+ // a SpanRegexQuery.
+ } else if (spanQuery instanceof FieldMaskingSpanQuery) {
+ return mustRewriteQuery(((FieldMaskingSpanQuery) spanQuery)
+ .getMaskedQuery());
+ } else if (spanQuery instanceof SpanFirstQuery) {
+ return mustRewriteQuery(((SpanFirstQuery) spanQuery).getMatch());
+ } else if (spanQuery instanceof SpanNearQuery) {
+ SpanQuery[] clauses = ((SpanNearQuery) spanQuery).getClauses();
+ for (int i = 0; i < clauses.length; i++) {
+ if (mustRewriteQuery(clauses[i])) {
+ return true;
+ }
+ }
+ return false;
+ } else if (spanQuery instanceof SpanNotQuery) {
+ SpanNotQuery spanNotQuery = (SpanNotQuery) spanQuery;
+ return mustRewriteQuery(spanNotQuery.getInclude())
+ || mustRewriteQuery(spanNotQuery.getExclude());
+ } else if (spanQuery instanceof SpanOrQuery) {
+ SpanQuery[] clauses = ((SpanOrQuery) spanQuery).getClauses();
+ for (int i = 0; i < clauses.length; i++) {
+ if (mustRewriteQuery(clauses[i])) {
+ return true;
+ }
+ }
+ return false;
+ } else if (spanQuery instanceof SpanTermQuery) {
+ return false;
+ } else {
+ return true;
+ }
+ }
+
+ /**
+ * This class makes sure that if both position sensitive and insensitive
+ * versions of the same term are added, the position insensitive one wins.
+ */
+ static private class PositionCheckingMap extends HashMap {
+
+ public void putAll(Map m) {
+ Iterator it = m.entrySet().iterator();
+ while (it.hasNext()) {
+ Map.Entry entry = (java.util.Map.Entry) it.next();
+ this.put(entry.getKey(), entry.getValue());
+ }
+ }
+
+ public Object put(Object key, Object value) {
+ Object prev = super.put(key, value);
+ if (prev == null)
+ return prev;
+ WeightedSpanTerm prevTerm = (WeightedSpanTerm) prev;
+ WeightedSpanTerm newTerm = (WeightedSpanTerm) value;
+ if (!prevTerm.positionSensitive) {
+ newTerm.positionSensitive = false;
+ }
+ return prev;
+ }
+
+ }
+
+ private MultiTermQuery copyMultiTermQuery(MultiTermQuery query) {
+ if (query instanceof TermRangeQuery) {
+ TermRangeQuery q = (TermRangeQuery) query;
+ q.setBoost(query.getBoost());
+ return new TermRangeQuery(q.getField(), q.getLowerTerm(), q
+ .getUpperTerm(), q.includesLower(), q.includesUpper());
+ } else if (query instanceof WildcardQuery) {
+ MultiTermQuery q = new WildcardQuery(query.getTerm());
+ q.setBoost(query.getBoost());
+ return q;
+ } else if (query instanceof PrefixQuery) {
+ MultiTermQuery q = new PrefixQuery(query.getTerm());
+ q.setBoost(q.getBoost());
+ return q;
+ } else if (query instanceof FuzzyQuery) {
+ FuzzyQuery q = (FuzzyQuery) query;
+ q.setBoost(q.getBoost());
+ return new FuzzyQuery(q.getTerm(), q.getMinSimilarity(), q
+ .getPrefixLength());
+ }
+
+ return query;
+ }
+
+ public boolean getExpandMultiTermQuery() {
+ return expandMultiTermQuery;
+ }
+
+ public void setExpandMultiTermQuery(boolean expandMultiTermQuery) {
+ this.expandMultiTermQuery = expandMultiTermQuery;
+ }
+
+ public boolean isCachedTokenStream() {
+ return cachedTokenStream;
+ }
+
+ public TokenStream getTokenStream() {
+ return tokenStream;
+ }
+
+ /**
+ * By default, {@link TokenStream}s that are not of the type
+ * {@link CachingTokenFilter} are wrapped in a {@link CachingTokenFilter} to
+ * ensure an efficient reset - if you are already using a different caching
+ * {@link TokenStream} impl and you don't want it to be wrapped, set this to
+ * false.
+ *
+ * @param wrap
+ */
+ public void setWrapIfNotCachingTokenFilter(boolean wrap) {
+ this.wrapToCaching = wrap;
+ }
}
Index: contrib/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTerm.java
===================================================================
--- contrib/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTerm.java (revision 908726)
+++ contrib/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTerm.java (working copy)
@@ -1,6 +1,5 @@
package org.apache.lucene.search.highlight;
-
/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -20,85 +19,100 @@
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
-
/**
* Lightweight class to hold term, weight, and positions used for scoring this
* term.
*/
-public class WeightedSpanTerm extends WeightedTerm{
- boolean positionSensitive;
- private List positionSpans = new ArrayList();
+public class WeightedSpanTerm extends WeightedTerm {
+ boolean positionSensitive = false; // TODO: Mike just changed this
+ private List positionSpans = new ArrayList();
- /**
- * @param weight
- * @param term
- */
- public WeightedSpanTerm(float weight, String term) {
- super(weight, term);
- this.positionSpans = new ArrayList();
- }
+ /**
+ * @param weight
+ * @param term
+ */
+ public WeightedSpanTerm(float weight, String term) {
+ super(weight, term);
+ this.positionSpans = new ArrayList();
+ }
- /**
- * @param weight
- * @param term
- * @param positionSensitive
- */
- public WeightedSpanTerm(float weight, String term, boolean positionSensitive) {
- super(weight, term);
- this.positionSensitive = positionSensitive;
- }
+ /**
+ * @param weight
+ * @param term
+ * @param positionSensitive
+ */
+ public WeightedSpanTerm(float weight, String term, boolean positionSensitive) {
+ super(weight, term);
+ this.positionSensitive = positionSensitive;
+ }
- /**
- * Checks to see if this term is valid at position.
- *
- * @param position
- * to check against valid term postions
- * @return true iff this term is a hit at this position
- */
- public boolean checkPosition(int position) {
- // There would probably be a slight speed improvement if PositionSpans
- // where kept in some sort of priority queue - that way this method
- // could
- // bail early without checking each PositionSpan.
- Iterator positionSpanIt = positionSpans.iterator();
+ /**
+ * Checks to see if this term is valid at position.
+ *
+ * @param position
+ * to check against valid term postions
+ * @return true iff this term is a hit at this position
+ */
+ public boolean checkPosition(int position) {
+ // There would probably be a slight speed improvement if PositionSpans
+ // where kept in some sort of priority queue - that way this method
+ // could
+ // bail early without checking each PositionSpan.
+ Iterator positionSpanIt = positionSpans.iterator();
+ boolean rv = false;
+ while (positionSpanIt.hasNext()) {
+ PositionSpan posSpan = (PositionSpan) positionSpanIt.next();
- while (positionSpanIt.hasNext()) {
- PositionSpan posSpan = (PositionSpan) positionSpanIt.next();
+ if (((position >= posSpan.start) && (position <= posSpan.end))) {
+ rv = true;
+ }
+ }
+ if ("fish".equals(getTerm())) {
+ System.err.println("checkPosition(" + position + ") is returning "
+ + rv + " for term \"" + getTerm() + "\"");
+ }
+ return rv;
+ }
- if (((position >= posSpan.start) && (position <= posSpan.end))) {
- return true;
- }
- }
+ public void addPositionSpans(List positionSpans) {
+ this.positionSpans.addAll(positionSpans);
+ }
- return false;
- }
+ public boolean isPositionSensitive() {
+ return positionSensitive;
+ }
- public void addPositionSpans(List positionSpans) {
- this.positionSpans.addAll(positionSpans);
- }
+ public void setPositionSensitive(boolean positionSensitive) {
+ this.positionSensitive = positionSensitive;
+ }
- public boolean isPositionSensitive() {
- return positionSensitive;
- }
-
- public void setPositionSensitive(boolean positionSensitive) {
- this.positionSensitive = positionSensitive;
- }
-
- public List getPositionSpans() {
- return positionSpans;
- }
+ public List getPositionSpans() {
+ return positionSpans;
+ }
}
-
// Utility class to store a Span
class PositionSpan {
- int start;
- int end;
+
+ int start;
+ int end;
+ // Set of Term.text which are valid for this span
+ Set