X-Git-Url: https://git.mdrn.pl/pylucene.git/blobdiff_plain/a2e61f0c04805cfcb8706176758d1283c7e3a55c..aaeed5504b982cf3545252ab528713250aa33eed:/lucene-java-3.5.0/lucene/src/java/org/apache/lucene/search/TermQuery.java diff --git a/lucene-java-3.5.0/lucene/src/java/org/apache/lucene/search/TermQuery.java b/lucene-java-3.5.0/lucene/src/java/org/apache/lucene/search/TermQuery.java new file mode 100644 index 0000000..3c64049 --- /dev/null +++ b/lucene-java-3.5.0/lucene/src/java/org/apache/lucene/search/TermQuery.java @@ -0,0 +1,236 @@ +package org.apache.lucene.search; + +/** + * 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.HashSet; +import java.util.Set; + +import org.apache.lucene.index.Term; +import org.apache.lucene.index.TermDocs; +import org.apache.lucene.index.IndexReader; +import org.apache.lucene.search.Explanation.IDFExplanation; +import org.apache.lucene.util.ReaderUtil; +import org.apache.lucene.util.ToStringUtils; + +/** A Query that matches documents containing a term. + This may be combined with other terms with a {@link BooleanQuery}. + */ +public class TermQuery extends Query { + private Term term; + + private class TermWeight extends Weight { + private final Similarity similarity; + private float value; + private float idf; + private float queryNorm; + private float queryWeight; + private IDFExplanation idfExp; + private final Set hash; + + public TermWeight(Searcher searcher) + throws IOException { + this.similarity = getSimilarity(searcher); + if (searcher instanceof IndexSearcher) { + hash = new HashSet(); + IndexReader ir = ((IndexSearcher)searcher).getIndexReader(); + final int dfSum[] = new int[1]; + new ReaderUtil.Gather(ir) { + @Override + protected void add(int base, IndexReader r) throws IOException { + int df = r.docFreq(term); + dfSum[0] += df; + if (df > 0) { + hash.add(r.hashCode()); + } + } + }.run(); + + idfExp = similarity.idfExplain(term, searcher, dfSum[0]); + } else { + idfExp = similarity.idfExplain(term, searcher); + hash = null; + } + + idf = idfExp.getIdf(); + } + + @Override + public String toString() { return "weight(" + TermQuery.this + ")"; } + + @Override + public Query getQuery() { return TermQuery.this; } + + @Override + public float getValue() { return value; } + + @Override + public float sumOfSquaredWeights() { + queryWeight = idf * getBoost(); // compute query weight + return queryWeight * queryWeight; // square it + } + + @Override + public void normalize(float queryNorm) { + this.queryNorm = queryNorm; + queryWeight *= queryNorm; // normalize query weight + value = queryWeight * idf; // idf for document + } + + @Override + public Scorer scorer(IndexReader reader, boolean scoreDocsInOrder, boolean topScorer) throws IOException { + // only use the early exit condition if we have an atomic reader, because Lucene 3.x still supports non-atomic readers here: + if (hash != null && reader.getSequentialSubReaders() == null && !hash.contains(reader.hashCode())) { + return null; + } + + TermDocs termDocs = reader.termDocs(term); + + if (termDocs == null) + return null; + + return new TermScorer(this, termDocs, similarity, reader.norms(term.field())); + } + + @Override + public Explanation explain(IndexReader reader, int doc) + throws IOException { + + ComplexExplanation result = new ComplexExplanation(); + result.setDescription("weight("+getQuery()+" in "+doc+"), product of:"); + + Explanation expl = new Explanation(idf, idfExp.explain()); + + // explain query weight + Explanation queryExpl = new Explanation(); + queryExpl.setDescription("queryWeight(" + getQuery() + "), product of:"); + + Explanation boostExpl = new Explanation(getBoost(), "boost"); + if (getBoost() != 1.0f) + queryExpl.addDetail(boostExpl); + queryExpl.addDetail(expl); + + Explanation queryNormExpl = new Explanation(queryNorm,"queryNorm"); + queryExpl.addDetail(queryNormExpl); + + queryExpl.setValue(boostExpl.getValue() * + expl.getValue() * + queryNormExpl.getValue()); + + result.addDetail(queryExpl); + + // explain field weight + String field = term.field(); + ComplexExplanation fieldExpl = new ComplexExplanation(); + fieldExpl.setDescription("fieldWeight("+term+" in "+doc+ + "), product of:"); + + Explanation tfExplanation = new Explanation(); + int tf = 0; + TermDocs termDocs = reader.termDocs(term); + if (termDocs != null) { + try { + if (termDocs.skipTo(doc) && termDocs.doc() == doc) { + tf = termDocs.freq(); + } + } finally { + termDocs.close(); + } + tfExplanation.setValue(similarity.tf(tf)); + tfExplanation.setDescription("tf(termFreq("+term+")="+tf+")"); + } else { + tfExplanation.setValue(0.0f); + tfExplanation.setDescription("no matching term"); + } + fieldExpl.addDetail(tfExplanation); + fieldExpl.addDetail(expl); + + Explanation fieldNormExpl = new Explanation(); + byte[] fieldNorms = reader.norms(field); + float fieldNorm = + fieldNorms!=null ? similarity.decodeNormValue(fieldNorms[doc]) : 1.0f; + fieldNormExpl.setValue(fieldNorm); + fieldNormExpl.setDescription("fieldNorm(field="+field+", doc="+doc+")"); + fieldExpl.addDetail(fieldNormExpl); + + fieldExpl.setMatch(Boolean.valueOf(tfExplanation.isMatch())); + fieldExpl.setValue(tfExplanation.getValue() * + expl.getValue() * + fieldNormExpl.getValue()); + + result.addDetail(fieldExpl); + result.setMatch(fieldExpl.getMatch()); + + // combine them + result.setValue(queryExpl.getValue() * fieldExpl.getValue()); + + if (queryExpl.getValue() == 1.0f) + return fieldExpl; + + return result; + } + } + + /** Constructs a query for the term t. */ + public TermQuery(Term t) { + term = t; + } + + /** Returns the term of this query. */ + public Term getTerm() { return term; } + + @Override + public Weight createWeight(Searcher searcher) throws IOException { + return new TermWeight(searcher); + } + + @Override + public void extractTerms(Set terms) { + terms.add(getTerm()); + } + + /** Prints a user-readable version of this query. */ + @Override + public String toString(String field) { + StringBuilder buffer = new StringBuilder(); + if (!term.field().equals(field)) { + buffer.append(term.field()); + buffer.append(":"); + } + buffer.append(term.text()); + buffer.append(ToStringUtils.boost(getBoost())); + return buffer.toString(); + } + + /** Returns true iff o is equal to this. */ + @Override + public boolean equals(Object o) { + if (!(o instanceof TermQuery)) + return false; + TermQuery other = (TermQuery)o; + return (this.getBoost() == other.getBoost()) + && this.term.equals(other.term); + } + + /** Returns a hash code value for this object.*/ + @Override + public int hashCode() { + return Float.floatToIntBits(getBoost()) ^ term.hashCode(); + } + +}