Java tutorial
package org.apache.blur.utils; /** * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import java.io.IOException; import java.util.Collection; import java.util.HashSet; import java.util.List; import org.apache.blur.analysis.FieldManager; import org.apache.blur.lucene.search.SuperQuery; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.TokenStream; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field.Store; import org.apache.lucene.document.StringField; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.IndexableField; import org.apache.lucene.index.Term; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanQuery; import org.apache.lucene.search.MultiPhraseQuery; import org.apache.lucene.search.NumericRangeQuery; import org.apache.lucene.search.PhraseQuery; import org.apache.lucene.search.PrefixQuery; import org.apache.lucene.search.Query; import org.apache.lucene.search.TermQuery; import org.apache.lucene.search.TermRangeQuery; import org.apache.lucene.search.WildcardQuery; import org.apache.lucene.search.highlight.Highlighter; import org.apache.lucene.search.highlight.InvalidTokenOffsetsException; import org.apache.lucene.search.highlight.QueryScorer; import org.apache.lucene.search.highlight.SimpleHTMLFormatter; import org.apache.lucene.search.highlight.TextFragment; import org.apache.lucene.search.highlight.TokenSources; import org.apache.lucene.util.BytesRef; public class HighlightHelper { private static final Collection<String> FIELDS_NOT_TO_HIGHLIGHT = new HashSet<String>() { private static final long serialVersionUID = 1L; { add(BlurConstants.ROW_ID); add(BlurConstants.RECORD_ID); add(BlurConstants.PRIME_DOC); add(BlurConstants.FAMILY); } }; /** * NOTE: This method will not preserve the correct field types. * * @param preTag * @param postTag */ public static Document highlight(int docId, Document document, Query query, FieldManager fieldManager, IndexReader reader, String preTag, String postTag) throws IOException, InvalidTokenOffsetsException { String fieldLessFieldName = fieldManager.getFieldLessFieldName(); Query fixedQuery = fixSuperQuery(query, null, fieldLessFieldName); Analyzer analyzer = fieldManager.getAnalyzerForQuery(); SimpleHTMLFormatter htmlFormatter = new SimpleHTMLFormatter(preTag, postTag); Document result = new Document(); for (IndexableField f : document) { String name = f.name(); if (fieldLessFieldName.equals(name) || FIELDS_NOT_TO_HIGHLIGHT.contains(name)) { result.add(f); continue; } String text = f.stringValue(); Number numericValue = f.numericValue(); Query fieldFixedQuery; if (fieldManager.isFieldLessIndexed(name)) { fieldFixedQuery = fixSuperQuery(query, name, fieldLessFieldName); } else { fieldFixedQuery = fixedQuery; } if (numericValue != null) { if (shouldNumberBeHighlighted(name, numericValue, fieldFixedQuery)) { String numberHighlight = preTag + text + postTag; result.add(new StringField(name, numberHighlight, Store.YES)); } } else { Highlighter highlighter = new Highlighter(htmlFormatter, new QueryScorer(fieldFixedQuery, name)); TokenStream tokenStream = TokenSources.getAnyTokenStream(reader, docId, name, analyzer); TextFragment[] frag = highlighter.getBestTextFragments(tokenStream, text, false, 10); for (int j = 0; j < frag.length; j++) { if ((frag[j] != null) && (frag[j].getScore() > 0)) { result.add(new StringField(name, frag[j].toString(), Store.YES)); } } } } return result; } private static Query fixSuperQuery(Query query, String name, String fieldLessFieldName) { if (query instanceof BooleanQuery) { BooleanQuery bq = (BooleanQuery) query; BooleanQuery newBq = new BooleanQuery(); for (BooleanClause booleanClause : bq) { newBq.add(fixSuperQuery(booleanClause.getQuery(), name, fieldLessFieldName), booleanClause.getOccur()); } return newBq; } else if (query instanceof SuperQuery) { SuperQuery sq = (SuperQuery) query; return setFieldIfNeeded(sq.getQuery(), name, fieldLessFieldName); } else { return setFieldIfNeeded(query, name, fieldLessFieldName); } } private static Query setFieldIfNeeded(Query query, String name, String fieldLessFieldName) { if (name == null) { return query; } if (query instanceof TermQuery) { TermQuery tq = (TermQuery) query; Term term = tq.getTerm(); if (term.field().equals(fieldLessFieldName)) { return new TermQuery(new Term(name, term.bytes())); } } else if (query instanceof WildcardQuery) { WildcardQuery wq = (WildcardQuery) query; Term term = wq.getTerm(); if (term.field().equals(fieldLessFieldName)) { return new WildcardQuery(new Term(name, term.bytes())); } } else if (query instanceof MultiPhraseQuery) { MultiPhraseQuery mpq = (MultiPhraseQuery) query; int[] positions = mpq.getPositions(); List<Term[]> termArrays = mpq.getTermArrays(); if (isTermField(termArrays, fieldLessFieldName)) { MultiPhraseQuery multiPhraseQuery = new MultiPhraseQuery(); multiPhraseQuery.setSlop(mpq.getSlop()); for (int i = 0; i < termArrays.size(); i++) { multiPhraseQuery.add(changeFields(termArrays.get(i), name), positions[i]); } return multiPhraseQuery; } } else if (query instanceof PhraseQuery) { PhraseQuery pq = (PhraseQuery) query; Term[] terms = pq.getTerms(); int[] positions = pq.getPositions(); String field = terms[0].field(); if (field.equals(BlurConstants.SUPER)) { PhraseQuery phraseQuery = new PhraseQuery(); for (int i = 0; i < terms.length; i++) { phraseQuery.add(new Term(name, terms[i].bytes()), positions[i]); } phraseQuery.setSlop(pq.getSlop()); return phraseQuery; } } else if (query instanceof PrefixQuery) { PrefixQuery pq = (PrefixQuery) query; Term term = pq.getPrefix(); if (term.field().equals(BlurConstants.SUPER)) { return new PrefixQuery(new Term(name, term.bytes())); } } else if (query instanceof TermRangeQuery) { TermRangeQuery trq = (TermRangeQuery) query; BytesRef lowerTerm = trq.getLowerTerm(); BytesRef upperTerm = trq.getUpperTerm(); boolean includeUpper = trq.includesUpper(); boolean includeLower = trq.includesLower(); String field = trq.getField(); if (field.equals(BlurConstants.SUPER)) { return new TermRangeQuery(name, lowerTerm, upperTerm, includeLower, includeUpper); } } return query; } private static Term[] changeFields(Term[] terms, String name) { Term[] newTerms = new Term[terms.length]; for (int i = 0; i < terms.length; i++) { newTerms[i] = new Term(name, terms[i].bytes()); } return newTerms; } private static boolean isTermField(List<Term[]> termArrays, String fieldName) { Term[] terms = termArrays.get(0); return terms[0].field().equals(fieldName); } public static boolean shouldNumberBeHighlighted(String name, Number numericValue, Query query) { if (query instanceof BooleanQuery) { BooleanQuery booleanQuery = (BooleanQuery) query; for (BooleanClause booleanClause : booleanQuery) { if (booleanClause.isProhibited()) { continue; } else { if (shouldNumberBeHighlighted(name, numericValue, booleanClause.getQuery())) { return true; } } } } else { if (query instanceof NumericRangeQuery) { if (numericValue instanceof Integer) { return checkInteger(name, numericValue, query); } else if (numericValue instanceof Double) { return checkDouble(name, numericValue, query); } else if (numericValue instanceof Float) { return checkFloat(name, numericValue, query); } else if (numericValue instanceof Long) { return checkLong(name, numericValue, query); } } } return false; } @SuppressWarnings("unchecked") public static boolean checkLong(String name, Number numericValue, Query query) { long value = (Long) numericValue; NumericRangeQuery<Long> nrq = (NumericRangeQuery<Long>) query; if (!name.equals(nrq.getField())) { return false; } if (nrq.includesMin()) { if (nrq.includesMax()) { if (value >= nrq.getMin() && value <= nrq.getMax()) { return true; } } else { if (value >= nrq.getMin() && value < nrq.getMax()) { return true; } } } else { if (nrq.includesMax()) { if (value > nrq.getMin() && value <= nrq.getMax()) { return true; } } else { if (value > nrq.getMin() && value < nrq.getMax()) { return true; } } } return false; } @SuppressWarnings("unchecked") public static boolean checkFloat(String name, Number numericValue, Query query) { float value = (Float) numericValue; NumericRangeQuery<Float> nrq = (NumericRangeQuery<Float>) query; if (!name.equals(nrq.getField())) { return false; } if (nrq.includesMin()) { if (nrq.includesMax()) { if (value >= nrq.getMin() && value <= nrq.getMax()) { return true; } } else { if (value >= nrq.getMin() && value < nrq.getMax()) { return true; } } } else { if (nrq.includesMax()) { if (value > nrq.getMin() && value <= nrq.getMax()) { return true; } } else { if (value > nrq.getMin() && value < nrq.getMax()) { return true; } } } return false; } @SuppressWarnings("unchecked") public static boolean checkDouble(String name, Number numericValue, Query query) { double value = (Double) numericValue; NumericRangeQuery<Double> nrq = (NumericRangeQuery<Double>) query; if (!name.equals(nrq.getField())) { return false; } if (nrq.includesMin()) { if (nrq.includesMax()) { if (value >= nrq.getMin() && value <= nrq.getMax()) { return true; } } else { if (value >= nrq.getMin() && value < nrq.getMax()) { return true; } } } else { if (nrq.includesMax()) { if (value > nrq.getMin() && value <= nrq.getMax()) { return true; } } else { if (value > nrq.getMin() && value < nrq.getMax()) { return true; } } } return false; } @SuppressWarnings("unchecked") public static boolean checkInteger(String name, Number numericValue, Query query) { int value = (Integer) numericValue; NumericRangeQuery<Integer> nrq = (NumericRangeQuery<Integer>) query; if (!name.equals(nrq.getField())) { return false; } if (nrq.includesMin()) { if (nrq.includesMax()) { if (value >= nrq.getMin() && value <= nrq.getMax()) { return true; } } else { if (value >= nrq.getMin() && value < nrq.getMax()) { return true; } } } else { if (nrq.includesMax()) { if (value > nrq.getMin() && value <= nrq.getMax()) { return true; } } else { if (value > nrq.getMin() && value < nrq.getMax()) { return true; } } } return false; } }