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))