/*
* 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.
*/
using System;
using Lucene.Net.Documents;
using Document = Lucene.Net.Documents.Document;
using FieldSelector = Lucene.Net.Documents.FieldSelector;
using CorruptIndexException = Lucene.Net.Index.CorruptIndexException;
using Term = Lucene.Net.Index.Term;
namespace Lucene.Net.Search
{
/// The interface for search implementations.
///
///
/// Searchable is the abstract network protocol for searching. Implementations
/// provide search over a single index, over multiple indices, and over indices
/// on remote servers.
///
///
/// Queries, filters and sort criteria are designed to be compact so that they
/// may be efficiently passed to a remote index, with only the top-scoring hits
/// being returned, rather than every matching hit.
///
/// NOTE: this interface is kept public for convenience. Since it is not
/// expected to be implemented directly, it may be changed unexpectedly between
/// releases.
///
public interface Searchable : IDisposable
{
/// Lower-level search API.
///
///
/// is called for every document.
/// Collector-based access to remote indexes is discouraged.
///
///
/// Applications should only use this if they need all of the matching
/// documents. The high-level search API () is
/// usually more efficient, as it skips non-high-scoring hits.
///
///
/// to match documents
///
/// if non-null, used to permit documents to be collected.
///
/// to receive hits
///
/// BooleanQuery.TooManyClauses
void Search(Weight weight, Filter filter, Collector collector);
/// Frees resources associated with this Searcher.
/// Be careful not to call this method while you are still using objects
/// that reference this searchable
///
void Close();
/// Expert: Returns the number of documents containing term.
/// Called by search code to compute term weights.
///
///
///
int DocFreq(Term term);
/// Expert: For each term in the terms array, calculates the number of
/// documents containing term. Returns an array with these
/// document frequencies. Used to minimize number of remote calls.
///
int[] DocFreqs(Term[] terms);
/// Expert: Returns one greater than the largest possible document number.
/// Called by search code to compute term weights.
///
///
///
int MaxDoc { get; }
///
/// Expert: Low-level search implementation. Finds the top n
/// hits for query, applying filter if non-null.
///
/// Applications should usually call or
/// instead.
///
/// BooleanQuery.TooManyClauses
TopDocs Search(Weight weight, Filter filter, int n);
/// Expert: Returns the stored fields of document i.
///
/// CorruptIndexException if the index is corrupt
/// IOException if there is a low-level IO error
Document Doc(int i);
/// Get the at the nth position. The
/// may be used to determine what s to load and how they should be loaded.
///
/// NOTE: If the underlying Reader (more specifically, the underlying FieldsReader) is closed before the lazy is
/// loaded an exception may be thrown. If you want the value of a lazy to be available after closing you must
/// explicitly load it or fetch the Document again with a new loader.
///
///
///
/// Get the document at the nth position
///
/// The to use to determine what Fields should be loaded on the Document. May be null, in which case all Fields will be loaded.
///
/// The stored fields of the at the nth position
///
/// CorruptIndexException if the index is corrupt
/// IOException if there is a low-level IO error
///
///
///
///
///
///
///
///
///
///
///
///
Document Doc(int n, FieldSelector fieldSelector);
/// Expert: called to re-write queries into primitive queries.
/// BooleanQuery.TooManyClauses
Query Rewrite(Query query);
/// Expert: low-level implementation method
/// Returns an Explanation that describes how doc scored against
/// weight.
///
/// This is intended to be used in developing Similarity implementations,
/// and, for good performance, should not be displayed with every hit.
/// Computing an explanation is as expensive as executing the query over the
/// entire index.
/// Applications should call .
///
/// BooleanQuery.TooManyClauses
Explanation Explain(Weight weight, int doc);
/// Expert: Low-level search implementation with arbitrary sorting. Finds
/// the top n hits for query, applying
/// filter if non-null, and sorting the hits by the criteria in
/// sort.
///
/// Applications should usually call
/// instead.
///
///
/// BooleanQuery.TooManyClauses
TopFieldDocs Search(Weight weight, Filter filter, int n, Sort sort);
}
}