The fields used to determine sort order must be carefully chosen. /// Documents must contain a single term in such a Field, /// and the value of the term should indicate the document's relative position in /// a given sort order. The Field must be indexed, but should not be tokenized, /// and does not need to be stored (unless you happen to want it back with the /// rest of your document data). In other words: /// ///
document.add (new Field ("byNumber", Integer.toString(x), Field.Store.NO, Field.Index.UN_TOKENIZED));
There are three possible kinds of term values which may be put into /// sorting fields: Integers, Floats, or Strings. Unless /// {@link SortField SortField} objects are specified, the type of value /// in the Field is determined by parsing the first term in the Field. /// ///
Integer term values should contain only digits and an optional
/// preceeding negative sign. Values must be base 10 and in the range
/// Integer.MIN_VALUE
and Integer.MAX_VALUE
inclusive.
/// Documents which should appear first in the sort
/// should have low value integers, later documents high values
/// (i.e. the documents should be numbered 1..n
where
/// 1
is the first and n
the last).
///
///
Float term values should conform to values accepted by
/// {@link Float Float.valueOf(String)} (except that NaN
/// and Infinity
are not supported).
/// Documents which should appear first in the sort
/// should have low values, later documents high values.
///
///
String term values can contain any valid String, but should /// not be tokenized. The values are sorted according to their /// {@link Comparable natural order}. Note that using this type /// of term value has higher memory requirements than the other /// two types. /// ///
One of these objects can be /// used multiple times and the sort order changed between usages. /// ///
This class is thread safe. /// ///
Sorting uses of caches of term values maintained by the
/// internal HitQueue(s). The cache is static and contains an integer
/// or float array of length IndexReader.maxDoc()
for each Field
/// name for which a sort is performed. In other words, the size of the
/// cache in bytes is:
///
///
4 * IndexReader.maxDoc() * (# of different fields actually used to sort)
///
///
For String fields, the cache is larger: in addition to the /// above array, the value of every term in the Field is kept in memory. /// If there are many unique terms in the Field, this could /// be quite large. /// ///
Note that the size of the cache is not affected by how many /// fields are in the index and might be used to sort - only by /// the ones actually used to sort a result set. /// ///
The cache is cleared each time a new IndexReader
is
/// passed in, or if the value returned by maxDoc()
/// changes for the current IndexReader. This class is not set up to
/// be able to efficiently sort hits from more than one index
/// simultaneously.
///
///
Created: Feb 12, 2004 10:53:57 AM /// ///
field
then by index order (document
/// number). The type of value in field
is determined
/// automatically.
///
/// field
then by
/// index order (document number). The type of value in field
is
/// determined automatically.
///
/// field
is determined automatically.
///
/// Field
then by index order
/// (document number).
/// Field
possibly in reverse,
/// then by index order (document number).
///