def count(self, *query, **options):
"""Return number of hits for given query or term.
:param query: :meth:`search` compatible query, or optimally a name and value
:param options: additional :meth:`search` options
"""
if len(query) > 1:
return self.docFreq(index.Term(*query))
query = self.parse(*query, **options) if query else Query.alldocs()
return super(IndexSearcher, self).count(query)
def phrase(cls, name: str, *values, **attrs) -> 'Query':
"""Return lucene MultiPhraseQuery. None may be used as a placeholder."""
builder = search.MultiPhraseQuery.Builder()
for attr in attrs:
setattr(builder, attr, attrs[attr])
for idx, words in enumerate(values):
if isinstance(words, str):
words = [words]
if words is not None:
builder.add([index.Term(name, word) for word in words], idx)
return builder.build()
def update(self, name, value='', document=(), **terms):
"""Atomically delete documents which match given term and add the new :meth:`document`.
.. versionchanged:: 1.7 update in-place if only DocValues are given
"""
doc = self.document(document, **terms)
term = index.Term(name, *[value] if value else doc.getValues(name))
fields = list(doc.iterator())
types = [Field.cast_(field.fieldType()) for field in fields]
if any(type.stored() or type.indexOptions() != index.IndexOptions.NONE
or type.pointDimensionCount() for type in types):
self.updateDocument(term, doc)
elif fields:
self.updateDocValues(term, *fields)
def suggest(self, name, value, count=1, **attrs):
"""Return spelling suggestions from DirectSpellChecker.
:param name: field name
:param value: term
:param count: maximum number of suggestions
:param attrs: DirectSpellChecker options
"""
checker = spell.DirectSpellChecker()
for attr in attrs:
setattr(checker, attr, attrs[attr])
return [
word.string for word in checker.suggestSimilar(
index.Term(name, value), count, self.indexReader)
]
def terms(self,
name,
value='',
stop='',
counts=False,
distance=0,
prefix=0):
"""Generate a slice of term values, optionally with frequency counts.
:param name: field name
:param value: term prefix, start value (given stop), or fuzzy value (given distance)
:param stop: optional upper bound for range terms
:param counts: include frequency counts
:param distance: maximum edit distance for fuzzy terms
:param prefix: prefix length for fuzzy terms
"""
terms = index.MultiFields.getTerms(self.indexReader, name)
if not terms:
return iter([])
term, termsenum = index.Term(name, value), terms.iterator()
if distance:
distance = (float if lucene6 else int)(distance)
terms = termsenum = search.FuzzyTermsEnum(terms,
util.AttributeSource(),
term, distance, prefix,
False)
else:
termsenum.seekCeil(util.BytesRef(value))
terms = itertools.chain([termsenum.term()],
util.BytesRefIterator.cast_(termsenum))
terms = map(operator.methodcaller('utf8ToString'), terms)
predicate = partial(operator.gt,
stop) if stop else operator.methodcaller(
'startswith', value)
if not distance:
terms = itertools.takewhile(predicate, terms)
return ((term, termsenum.docFreq())
for term in terms) if counts else terms
def span(cls, *term) -> 'SpanQuery':
"""Return `SpanQuery`_ from term name and value or a MultiTermQuery."""
if len(term) <= 1:
return SpanQuery(spans.SpanMultiTermQueryWrapper, *term)
return SpanQuery(spans.SpanTermQuery, index.Term(*term))
def prefix(cls, name: str, value) -> 'Query':
"""Return lucene PrefixQuery."""
return cls(search.PrefixQuery, index.Term(name, value))
def suggest(self, term: index.Term) -> index.Term:
"""Return term with text replaced as necessary."""
field = term.field()
words = self.searcher.suggest(field, term.text())
return index.Term(field, *words) if words else term
def term(cls, name: str, value) -> 'Query':
"""Return lucene TermQuery."""
return cls(search.TermQuery, index.Term(name, value))
def regexp(cls, name: str, value, *args) -> 'Query':
"""Return lucene RegexpQuery."""
return cls(search.RegexpQuery, index.Term(name, value), *args)
def fuzzy(cls, name: str, value, *args) -> 'Query':
"""Return lucene FuzzyQuery."""
return cls(search.FuzzyQuery, index.Term(name, value), *args)
def wildcard(cls, name: str, value) -> 'Query':
"""Return lucene WildcardQuery."""
return cls(search.WildcardQuery, index.Term(name, value))
