use crate::core::document::lat_lon_point_distance_comparator::LatLonPointDistanceComparator;
use crate::core::document::xy_point_distance_comparator::XYPointDistanceComparator;
use crate::core::index::binary_doc_values::BinaryDocValues;
use crate::core::index::doc_values::{Binary, DocValues};
use crate::core::index::index_reader_context::IndexReaderContext;
use crate::core::index::leaf_reader::LeafReader;
use crate::core::index::leaf_reader_context::LeafReaderContext;
use crate::core::index::{BytesRef, BytesRefValue};
use crate::core::search::comparators::doc_comparator::DocComparator;
use crate::core::search::comparators::double_comparator::DoubleComparator;
use crate::core::search::comparators::float_comparator::FloatComparator;
use crate::core::search::comparators::int_comparator::IntComparator;
use crate::core::search::comparators::long_comparator::LongComparator;
use crate::core::search::comparators::term_ord_val_comparator::TermOrdValComparator;
use crate::core::search::dummy::dummy_disi::DummyDISI;
use crate::core::search::dummy::dummy_field_comparator::DummyFieldComparator;
use crate::core::search::field_doc::FieldDoc;
use crate::core::search::leaf_field_comparator::{LeafFieldComparator, LeafFieldComparatorEnum};
use crate::core::search::scorable::Scorable;
use crate::core::search::sorted_numeric_sort_field::{
SortedNumericDoubleComparator, SortedNumericFloatComparator, SortedNumericIntComparator,
SortedNumericLongComparator,
};
use crate::core::search::sorted_set_sort_field::SortedDocValuesTermOrdValComparator;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::core::util::{CoreHelper, ToInt};
use crate::impl_from_for_enum;
use std::cmp::Ordering;
use std::sync::Arc;
pub(crate) enum TermTopValue {
Owned(BytesRef<Vec<u8>>),
After {
doc: Arc<FieldDoc>,
field_index: usize,
},
}
impl TermTopValue {
pub(crate) fn as_ref(&self) -> Result<&BytesRef<Vec<u8>>> {
match self {
Self::Owned(value) => Ok(value),
Self::After { doc, field_index } => doc
.fields
.get(*field_index)
.and_then(FieldComparatorValue::as_term_val)
.ok_or_else(|| LuceneError::illegal_state("expected term value comparator value")),
}
}
}
pub trait FieldComparator {
type V: PartialOrd;
fn compare(&self, slot1: usize, slot2: usize) -> i32;
fn set_top_value(&mut self, value: Self::V) -> Result<()>;
fn value(&self, slot: usize) -> Option<Self::V>;
type LeafFieldComparator<LR>: LeafFieldComparator
where
LR: LeafReader;
fn get_leaf_comparator<LR>(
&mut self,
context: &LeafReaderContext<LR>,
) -> Result<Self::LeafFieldComparator<LR>>
where
LR: LeafReader;
fn compare_values(&self, first: Option<&Self::V>, second: Option<&Self::V>) -> Result<i32> {
match (first, second) {
(None, None) => Ok(0),
(None, Some(_)) => Ok(-1),
(Some(_), None) => Ok(1),
(Some(f), Some(s)) => {
match f.partial_cmp(s) {
Some(ord) => Ok(ord.to_int()),
None => self.fallback_compare(f, s),
}
},
}
}
fn fallback_compare(&self, _first: &Self::V, _second: &Self::V) -> Result<i32> {
Err(LuceneError::unsupported_operation(
"fallback_compare must be implemented if the value type is not fully comparable",
))
}
fn set_single_sort(&mut self) {}
fn disable_skipping(&mut self) {}
}
pub struct RelevanceComparator {
pub(crate) scores: Vec<f32>,
pub(crate) bottom: f32,
pub(crate) top_value: f32,
}
impl RelevanceComparator {
pub fn new(num_hits: usize) -> Self {
Self {
scores: vec![0.0; num_hits],
bottom: 0.0,
top_value: 0.0,
}
}
}
impl FieldComparator for RelevanceComparator {
type V = f32;
fn compare(&self, slot1: usize, slot2: usize) -> i32 {
let slot1_v = self.scores[slot2];
let slot2_v = self.scores[slot1];
CoreHelper::compare_f32(slot1_v, slot2_v).to_int()
}
fn set_top_value(&mut self, value: Self::V) -> Result<()> {
self.top_value = value;
Ok(())
}
fn value(&self, slot: usize) -> Option<Self::V> {
Some(self.scores[slot])
}
type LeafFieldComparator<LR>
= RelevanceLeafComparator
where
LR: LeafReader;
fn get_leaf_comparator<LR>(
&mut self,
_context: &LeafReaderContext<LR>,
) -> Result<Self::LeafFieldComparator<LR>>
where
LR: LeafReader,
{
Ok(RelevanceLeafComparator::new())
}
fn compare_values(&self, first: Option<&Self::V>, second: Option<&Self::V>) -> Result<i32> {
match (first, second) {
(Some(&f), Some(&s)) => Ok(CoreHelper::compare_f32(s, f).to_int()),
(None, Some(_)) => Ok(1),
(Some(_), None) => Ok(-1),
(None, None) => Ok(0),
}
}
fn fallback_compare(&self, first: &Self::V, second: &Self::V) -> Result<i32> {
Ok(if first.is_nan() && second.is_nan() {
0
} else if first.is_nan() {
1
} else if second.is_nan() {
-1
} else {
0
})
}
}
pub struct RelevanceLeafComparator;
impl Default for RelevanceLeafComparator {
fn default() -> Self {
Self::new()
}
}
impl RelevanceLeafComparator {
pub fn new() -> Self {
Self
}
}
impl LeafFieldComparator for RelevanceLeafComparator {
type FieldComparator = RelevanceComparator;
fn set_bottom(&mut self, slot: usize, comparator: &mut Self::FieldComparator) -> Result<()> {
comparator.bottom = comparator.scores[slot];
Ok(())
}
fn compare_bottom<S>(
&mut self,
_doc: i32,
scorer: &mut S,
comparator: &mut Self::FieldComparator,
) -> Result<i32>
where
S: Scorable + ?Sized,
{
let doc_value = scorer.score()?;
debug_assert!(!doc_value.is_nan());
Ok(CoreHelper::compare_f32(doc_value, comparator.bottom).to_int())
}
fn compare_top<S>(
&mut self,
_doc: i32,
scorer: &mut S,
comparator: &mut Self::FieldComparator,
) -> Result<i32>
where
S: Scorable + ?Sized,
{
let doc_value = scorer.score()?;
debug_assert!(!doc_value.is_nan());
Ok(CoreHelper::compare_f32(doc_value, comparator.top_value).to_int())
}
fn copy<S>(
&mut self,
slot: usize,
_doc: i32,
scorer: &mut S,
comparator: &mut Self::FieldComparator,
) -> Result<()>
where
S: Scorable + ?Sized,
{
let score = scorer.score()?;
comparator.scores[slot] = score;
debug_assert!(!score.is_nan());
Ok(())
}
fn set_scorer<S>(
&mut self,
_scorer: &mut S,
_comparator: &mut Self::FieldComparator,
) -> Result<()>
where
S: Scorable + ?Sized,
{
Ok(())
}
type DocIdSetIteratorRef<'a> = &'a mut DummyDISI;
}
#[derive(Debug, Clone, Default)]
pub enum FieldComparatorValue {
#[default]
Missing,
Double(f64),
Float(f32),
Int(i32),
Long(i64),
TermVal(BytesRef<Vec<u8>>),
}
impl PartialEq for FieldComparatorValue {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(Self::Missing, Self::Missing) => true,
(Self::Double(a), Self::Double(b)) => CoreHelper::compare_f64(*a, *b).is_eq(),
(Self::Float(a), Self::Float(b)) => CoreHelper::compare_f32(*a, *b).is_eq(),
(Self::Int(a), Self::Int(b)) => a == b,
(Self::Long(a), Self::Long(b)) => a == b,
(Self::TermVal(a), Self::TermVal(b)) => a == b,
_ => false,
}
}
}
impl_from_for_enum!(
FieldComparatorValue,
i32 => Int,
i64 => Long,
f32 => Float,
f64 => Double,
BytesRef<Vec<u8>> => TermVal,
);
impl FieldComparatorValue {
pub fn missing() -> Self {
FieldComparatorValue::Missing
}
pub fn as_i32(&self) -> Option<&i32> {
match self {
FieldComparatorValue::Int(v) => Some(v),
_ => None,
}
}
pub fn into_i32(self) -> Option<i32> {
match self {
FieldComparatorValue::Int(v) => Some(v),
_ => None,
}
}
pub fn as_i64(&self) -> Option<&i64> {
match self {
FieldComparatorValue::Long(v) => Some(v),
_ => None,
}
}
pub fn into_i64(self) -> Option<i64> {
match self {
FieldComparatorValue::Long(v) => Some(v),
_ => None,
}
}
pub fn as_f32(&self) -> Option<&f32> {
match self {
FieldComparatorValue::Float(v) => Some(v),
_ => None,
}
}
pub fn into_f32(self) -> Option<f32> {
match self {
FieldComparatorValue::Float(v) => Some(v),
_ => None,
}
}
pub fn as_f64(&self) -> Option<&f64> {
match self {
FieldComparatorValue::Double(v) => Some(v),
_ => None,
}
}
pub fn into_f64(self) -> Option<f64> {
match self {
FieldComparatorValue::Double(v) => Some(v),
_ => None,
}
}
pub fn as_term_val(&self) -> Option<&BytesRef<Vec<u8>>> {
match self {
FieldComparatorValue::TermVal(v) => Some(v),
FieldComparatorValue::Missing => None,
_ => None,
}
}
pub fn into_term_val(self) -> Option<BytesRef<Vec<u8>>> {
match self {
FieldComparatorValue::TermVal(v) => Some(v),
_ => None,
}
}
}
impl PartialOrd for FieldComparatorValue {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
match (self, other) {
(FieldComparatorValue::Missing, FieldComparatorValue::Missing) => Some(Ordering::Equal),
(FieldComparatorValue::Int(a), FieldComparatorValue::Int(b)) => a.partial_cmp(b),
(FieldComparatorValue::Double(a), FieldComparatorValue::Double(b)) => {
Some(CoreHelper::compare_f64(*a, *b))
},
(FieldComparatorValue::Float(a), FieldComparatorValue::Float(b)) => {
Some(CoreHelper::compare_f32(*a, *b))
},
(FieldComparatorValue::Long(a), FieldComparatorValue::Long(b)) => a.partial_cmp(b),
(FieldComparatorValue::TermVal(a), FieldComparatorValue::TermVal(b)) => Some(a.cmp(b)),
_ => None,
}
}
}
pub enum FieldComparatorEnum {
Relevance(RelevanceComparator),
Doc(DocComparator),
Double(DoubleComparator),
Float(FloatComparator),
Int(IntComparator),
LatLonPointDistance(LatLonPointDistanceComparator),
Long(LongComparator),
TermVal(TermValComparator),
TermOrdValue(TermOrdValComparator),
SortedNumericInt(SortedNumericIntComparator),
SortedNumericLong(SortedNumericLongComparator),
SortedNumericFloat(SortedNumericFloatComparator),
SortedNumericDouble(SortedNumericDoubleComparator),
SortedDocValuesTermOrdVal(SortedDocValuesTermOrdValComparator),
XYPointDistance(XYPointDistanceComparator),
Dummy(DummyFieldComparator),
}
impl Default for FieldComparatorEnum {
fn default() -> Self {
FieldComparatorEnum::Dummy(DummyFieldComparator)
}
}
impl_from_for_enum!(
FieldComparatorEnum,
RelevanceComparator => Relevance,
DocComparator => Doc,
DoubleComparator => Double,
FloatComparator => Float,
IntComparator => Int,
LongComparator => Long,
TermValComparator => TermVal,
TermOrdValComparator => TermOrdValue,
SortedNumericIntComparator => SortedNumericInt,
SortedNumericLongComparator => SortedNumericLong,
SortedNumericFloatComparator => SortedNumericFloat,
SortedNumericDoubleComparator => SortedNumericDouble,
SortedDocValuesTermOrdValComparator => SortedDocValuesTermOrdVal,
LatLonPointDistanceComparator => LatLonPointDistance,
XYPointDistanceComparator => XYPointDistance,
DummyFieldComparator => Dummy,
);
impl FieldComparatorEnum {
pub(crate) fn set_top_value_from_after(
&mut self,
after: &Arc<FieldDoc>,
field_index: usize,
) -> Result<()> {
let value = after
.fields
.get(field_index)
.ok_or_else(|| LuceneError::illegal_state("missing search_after comparator value"))?;
match self {
Self::TermVal(comparator) => {
value
.as_term_val()
.ok_or_else(|| LuceneError::illegal_state("expected term value comparator value"))?;
comparator.top_value = Some(TermTopValue::After {
doc: Arc::clone(after),
field_index,
});
Ok(())
},
Self::TermOrdValue(comparator) => {
value
.as_term_val()
.ok_or_else(|| LuceneError::illegal_state("expected term ord value comparator value"))?;
comparator.top_value = Some(TermTopValue::After {
doc: Arc::clone(after),
field_index,
});
Ok(())
},
Self::SortedDocValuesTermOrdVal(comparator) => {
value.as_term_val().ok_or_else(|| {
LuceneError::illegal_state("expected sorted doc values term ord val comparator value")
})?;
comparator.base.top_value = Some(TermTopValue::After {
doc: Arc::clone(after),
field_index,
});
Ok(())
},
_ => self.set_top_value(value.clone()),
}
}
}
impl FieldComparator for FieldComparatorEnum {
type V = FieldComparatorValue;
fn compare(&self, slot1: usize, slot2: usize) -> i32 {
match self {
FieldComparatorEnum::Relevance(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::Doc(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::Double(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::Float(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::Int(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::Long(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::TermVal(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::TermOrdValue(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::SortedNumericInt(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::SortedNumericLong(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::SortedNumericFloat(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::SortedNumericDouble(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::SortedDocValuesTermOrdVal(comparator) => {
comparator.compare(slot1, slot2)
},
FieldComparatorEnum::LatLonPointDistance(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::XYPointDistance(comparator) => comparator.compare(slot1, slot2),
FieldComparatorEnum::Dummy(comparator) => comparator.compare(slot1, slot2),
}
}
fn set_top_value(&mut self, value: Self::V) -> Result<()> {
match self {
FieldComparatorEnum::Relevance(comparator) => {
let v = value
.into_f32()
.ok_or_else(|| LuceneError::illegal_state("expected relevance comparator value"))?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::Doc(comparator) => {
let v = value
.into_i32()
.ok_or_else(|| LuceneError::illegal_state("expected doc comparator value"))?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::Double(comparator) => {
let v = value
.into_f64()
.ok_or_else(|| LuceneError::illegal_state("expected double comparator value"))?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::Float(comparator) => {
let v = value
.into_f32()
.ok_or_else(|| LuceneError::illegal_state("expected float comparator value"))?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::Int(comparator) => {
let v = value
.into_i32()
.ok_or_else(|| LuceneError::illegal_state("expected int comparator value"))?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::Long(comparator) => {
let v = value
.into_i64()
.ok_or_else(|| LuceneError::illegal_state("expected long comparator value"))?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::TermVal(comparator) => {
let v = value
.into_term_val()
.ok_or_else(|| LuceneError::illegal_state("expected term value comparator value"))?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::TermOrdValue(comparator) => {
let v = value
.into_term_val()
.ok_or_else(|| LuceneError::illegal_state("expected term ord value comparator value"))?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::SortedNumericInt(comparator) => {
let v = value.into_i32().ok_or_else(|| {
LuceneError::illegal_state("expected sorted numeric int comparator value")
})?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::SortedNumericLong(comparator) => {
let v = value.into_i64().ok_or_else(|| {
LuceneError::illegal_state("expected sorted numeric long comparator value")
})?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::SortedNumericFloat(comparator) => {
let v = value.into_f32().ok_or_else(|| {
LuceneError::illegal_state("expected sorted numeric float comparator value")
})?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::SortedNumericDouble(comparator) => {
let v = value.into_f64().ok_or_else(|| {
LuceneError::illegal_state("expected sorted numeric double comparator value")
})?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::SortedDocValuesTermOrdVal(comparator) => {
let v = value.into_term_val().ok_or_else(|| {
LuceneError::illegal_state("expected sorted doc values term ord val comparator value")
})?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::LatLonPointDistance(comparator) => {
let v = value.into_f64().ok_or_else(|| {
LuceneError::illegal_state("expected lat lon point distance comparator value")
})?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::XYPointDistance(comparator) => {
let v = value.into_f64().ok_or_else(|| {
LuceneError::illegal_state("expected xy point distance comparator value")
})?;
comparator.set_top_value(v)?;
},
FieldComparatorEnum::Dummy(_comparator) => {
dummy_unreachable!()
},
}
Ok(())
}
fn value(&self, slot: usize) -> Option<Self::V> {
match self {
FieldComparatorEnum::Relevance(comparator) => {
comparator.value(slot).map(FieldComparatorValue::Float)
},
FieldComparatorEnum::Doc(comparator) => comparator.value(slot).map(FieldComparatorValue::Int),
FieldComparatorEnum::Double(comparator) => {
comparator.value(slot).map(FieldComparatorValue::Double)
},
FieldComparatorEnum::Float(comparator) => {
comparator.value(slot).map(FieldComparatorValue::Float)
},
FieldComparatorEnum::Int(comparator) => comparator.value(slot).map(FieldComparatorValue::Int),
FieldComparatorEnum::Long(comparator) => {
comparator.value(slot).map(FieldComparatorValue::Long)
},
FieldComparatorEnum::TermVal(comparator) => {
comparator.value(slot).map(FieldComparatorValue::TermVal)
},
FieldComparatorEnum::TermOrdValue(comparator) => {
comparator.value(slot).map(FieldComparatorValue::TermVal)
},
FieldComparatorEnum::SortedNumericInt(comparator) => {
comparator.value(slot).map(FieldComparatorValue::Int)
},
FieldComparatorEnum::SortedNumericLong(comparator) => {
comparator.value(slot).map(FieldComparatorValue::Long)
},
FieldComparatorEnum::SortedNumericFloat(comparator) => {
comparator.value(slot).map(FieldComparatorValue::Float)
},
FieldComparatorEnum::SortedNumericDouble(comparator) => {
comparator.value(slot).map(FieldComparatorValue::Double)
},
FieldComparatorEnum::SortedDocValuesTermOrdVal(comparator) => {
comparator.value(slot).map(FieldComparatorValue::TermVal)
},
FieldComparatorEnum::LatLonPointDistance(comparator) => {
comparator.value(slot).map(FieldComparatorValue::Double)
},
FieldComparatorEnum::XYPointDistance(comparator) => {
comparator.value(slot).map(FieldComparatorValue::Double)
},
FieldComparatorEnum::Dummy(_comparator) => {
dummy_unreachable!()
},
}
}
type LeafFieldComparator<LR>
= LeafFieldComparatorEnum<LR>
where
LR: LeafReader;
fn get_leaf_comparator<LR>(
&mut self,
context: &LeafReaderContext<LR>,
) -> Result<Self::LeafFieldComparator<LR>>
where
LR: LeafReader,
{
match self {
FieldComparatorEnum::Relevance(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::Relevance),
FieldComparatorEnum::Doc(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::Doc),
FieldComparatorEnum::Double(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::Double),
FieldComparatorEnum::Float(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::Float),
FieldComparatorEnum::Int(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::Int),
FieldComparatorEnum::Long(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::Long),
FieldComparatorEnum::TermVal(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::TermVal),
FieldComparatorEnum::TermOrdValue(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::TermOrdVal),
FieldComparatorEnum::SortedNumericInt(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::Int),
FieldComparatorEnum::SortedNumericLong(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::Long),
FieldComparatorEnum::SortedNumericFloat(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::Float),
FieldComparatorEnum::SortedNumericDouble(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::Double),
FieldComparatorEnum::SortedDocValuesTermOrdVal(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::TermOrdVal),
FieldComparatorEnum::LatLonPointDistance(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::LatLonPointDistance),
FieldComparatorEnum::XYPointDistance(comparator) => comparator
.get_leaf_comparator(context)
.map(LeafFieldComparatorEnum::XYPointDistance),
FieldComparatorEnum::Dummy(_) => {
dummy_unreachable!()
},
}
}
fn compare_values(&self, first: Option<&Self::V>, second: Option<&Self::V>) -> Result<i32> {
match self {
FieldComparatorEnum::Relevance(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_f32),
second.and_then(FieldComparatorValue::as_f32),
),
FieldComparatorEnum::Doc(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_i32),
second.and_then(FieldComparatorValue::as_i32),
),
FieldComparatorEnum::Double(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_f64),
second.and_then(FieldComparatorValue::as_f64),
),
FieldComparatorEnum::Float(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_f32),
second.and_then(FieldComparatorValue::as_f32),
),
FieldComparatorEnum::Int(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_i32),
second.and_then(FieldComparatorValue::as_i32),
),
FieldComparatorEnum::Long(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_i64),
second.and_then(FieldComparatorValue::as_i64),
),
FieldComparatorEnum::TermVal(comparator) => {
<TermValComparator as FieldComparator>::compare_values(
comparator,
first.and_then(FieldComparatorValue::as_term_val),
second.and_then(FieldComparatorValue::as_term_val),
)
},
FieldComparatorEnum::TermOrdValue(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_term_val),
second.and_then(FieldComparatorValue::as_term_val),
),
FieldComparatorEnum::SortedNumericInt(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_i32),
second.and_then(FieldComparatorValue::as_i32),
),
FieldComparatorEnum::SortedNumericLong(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_i64),
second.and_then(FieldComparatorValue::as_i64),
),
FieldComparatorEnum::SortedNumericFloat(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_f32),
second.and_then(FieldComparatorValue::as_f32),
),
FieldComparatorEnum::SortedNumericDouble(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_f64),
second.and_then(FieldComparatorValue::as_f64),
),
FieldComparatorEnum::SortedDocValuesTermOrdVal(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_term_val),
second.and_then(FieldComparatorValue::as_term_val),
),
FieldComparatorEnum::LatLonPointDistance(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_f64),
second.and_then(FieldComparatorValue::as_f64),
),
FieldComparatorEnum::XYPointDistance(comparator) => comparator.compare_values(
first.and_then(FieldComparatorValue::as_f64),
second.and_then(FieldComparatorValue::as_f64),
),
FieldComparatorEnum::Dummy(_) => {
dummy_unreachable!()
},
}
}
fn fallback_compare(&self, first: &Self::V, second: &Self::V) -> Result<i32> {
match self {
FieldComparatorEnum::Double(comparator) => match (first.as_f64(), second.as_f64()) {
(Some(first), Some(second)) => comparator.fallback_compare(first, second),
_ => Err(LuceneError::illegal_state(
"double fallback comparison received non-double values",
)),
},
FieldComparatorEnum::Float(comparator) => match (first.as_f32(), second.as_f32()) {
(Some(first), Some(second)) => comparator.fallback_compare(first, second),
_ => Err(LuceneError::illegal_state(
"float fallback comparison received non-float values",
)),
},
FieldComparatorEnum::SortedNumericDouble(comparator) => {
match (first.as_f64(), second.as_f64()) {
(Some(first), Some(second)) => comparator.fallback_compare(first, second),
_ => Err(LuceneError::illegal_state(
"sorted numeric double fallback comparison received non-double values",
)),
}
},
FieldComparatorEnum::SortedNumericFloat(comparator) => {
match (first.as_f32(), second.as_f32()) {
(Some(first), Some(second)) => comparator.fallback_compare(first, second),
_ => Err(LuceneError::illegal_state(
"sorted numeric float fallback comparison received non-float values",
)),
}
},
FieldComparatorEnum::Dummy(_) => {
dummy_unreachable!()
},
_ => Err(LuceneError::unsupported_operation(
"fallback comparison is not supported for this field comparator",
)),
}
}
fn set_single_sort(&mut self) {
match self {
FieldComparatorEnum::Relevance(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::Doc(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::Double(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::Float(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::Int(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::Long(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::TermVal(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::TermOrdValue(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::SortedNumericInt(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::SortedNumericLong(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::SortedNumericFloat(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::SortedNumericDouble(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::SortedDocValuesTermOrdVal(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::LatLonPointDistance(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::XYPointDistance(comparator) => comparator.set_single_sort(),
FieldComparatorEnum::Dummy(comparator) => comparator.set_single_sort(),
}
}
fn disable_skipping(&mut self) {
match self {
FieldComparatorEnum::Relevance(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::Doc(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::Double(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::Float(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::Int(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::Long(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::TermVal(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::TermOrdValue(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::SortedNumericInt(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::SortedNumericLong(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::SortedNumericFloat(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::SortedNumericDouble(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::SortedDocValuesTermOrdVal(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::LatLonPointDistance(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::XYPointDistance(comparator) => comparator.disable_skipping(),
FieldComparatorEnum::Dummy(comparator) => comparator.disable_skipping(),
}
}
}
pub struct TermValComparator {
pub(crate) values: Vec<Option<BytesRef<Vec<u8>>>>,
pub(crate) field: String,
pub(crate) bottom: usize,
pub(crate) top_value: Option<TermTopValue>,
pub(crate) missing_sort_cmp: i32,
}
impl TermValComparator {
pub fn new<FName>(field: FName, num_hits: usize, sort_missing_last: bool) -> Self
where
FName: Into<String>,
{
let field = field.into();
Self {
values: vec![None; num_hits],
field,
bottom: 0,
top_value: None,
missing_sort_cmp: if sort_missing_last { 1 } else { -1 },
}
}
fn compare_values(
&self,
val1: Option<&BytesRef<Vec<u8>>>,
val2: Option<&BytesRef<Vec<u8>>>,
) -> i32 {
match (val1, val2) {
(None, None) => 0,
(None, Some(_)) => self.missing_sort_cmp,
(Some(_), None) => -self.missing_sort_cmp,
(Some(v1), Some(v2)) => v1.cmp(v2).to_int(),
}
}
fn compare_value_bytes(&self, val1: Option<&[u8]>, val2: Option<&[u8]>) -> i32 {
match (val1, val2) {
(None, None) => 0,
(None, Some(_)) => self.missing_sort_cmp,
(Some(_), None) => -self.missing_sort_cmp,
(Some(v1), Some(v2)) => v1.cmp(v2).to_int(),
}
}
}
impl FieldComparator for TermValComparator {
type V = BytesRef<Vec<u8>>;
fn compare(&self, slot1: usize, slot2: usize) -> i32 {
let val1 = self.values[slot1].as_ref();
let val2 = self.values[slot2].as_ref();
self.compare_values(val1, val2)
}
fn set_top_value(&mut self, value: Self::V) -> Result<()> {
self.top_value = Some(TermTopValue::Owned(value));
Ok(())
}
fn value(&self, slot: usize) -> Option<Self::V> {
self.values[slot].clone()
}
type LeafFieldComparator<LR>
= TermValLeafComparator<Binary<LR>>
where
LR: LeafReader;
fn get_leaf_comparator<LR>(
&mut self,
context: &LeafReaderContext<LR>,
) -> Result<Self::LeafFieldComparator<LR>>
where
LR: LeafReader,
{
let doc_terms = DocValues::get_binary(context.reader(), &self.field)?;
Ok(TermValLeafComparator::new(doc_terms))
}
fn compare_values(&self, first: Option<&Self::V>, second: Option<&Self::V>) -> Result<i32> {
Ok(match (first, second) {
(Some(f), Some(s)) => f.cmp(s).to_int(),
(None, Some(_)) => self.missing_sort_cmp,
(Some(_), None) => -self.missing_sort_cmp,
(None, None) => 0,
})
}
}
pub struct TermValLeafComparator<B> {
doc_terms: B,
}
impl<B> TermValLeafComparator<B> {
pub fn new(doc_terms: B) -> Self {
Self { doc_terms }
}
}
impl<B> TermValLeafComparator<B>
where
B: BinaryDocValues,
{
fn get_value_for_doc(doc_terms: &mut B, doc: i32) -> Result<Option<B::Value<'_>>> {
if doc_terms.advance_exact(doc)? {
Ok(Some(doc_terms.binary_value()?))
} else {
Ok(None)
}
}
}
impl<B> LeafFieldComparator for TermValLeafComparator<B>
where
B: BinaryDocValues,
{
type FieldComparator = TermValComparator;
fn set_bottom(&mut self, slot: usize, comparator: &mut Self::FieldComparator) -> Result<()> {
comparator.bottom = slot;
Ok(())
}
fn compare_bottom<S>(
&mut self,
doc: i32,
_scorer: &mut S,
comparator: &mut Self::FieldComparator,
) -> Result<i32>
where
S: Scorable + ?Sized,
{
let (comparator, doc_terms) = (&comparator, &mut self.doc_terms);
let val = Self::get_value_for_doc(doc_terms, doc)?;
let bottom_value = comparator.values[comparator.bottom]
.as_ref()
.map(BytesRefValue::as_bytes);
Ok(comparator.compare_value_bytes(bottom_value, val.as_ref().map(BytesRefValue::as_bytes)))
}
fn compare_top<S>(
&mut self,
doc: i32,
_scorer: &mut S,
comparator: &mut Self::FieldComparator,
) -> Result<i32>
where
S: Scorable + ?Sized,
{
let (comparator, doc_terms) = (&comparator, &mut self.doc_terms);
let doc_value = Self::get_value_for_doc(doc_terms, doc)?;
let top_value = comparator
.top_value
.as_ref()
.map(TermTopValue::as_ref)
.transpose()?;
Ok(comparator.compare_value_bytes(
top_value.map(BytesRefValue::as_bytes),
doc_value.as_ref().map(BytesRefValue::as_bytes),
))
}
fn copy<S>(
&mut self,
slot: usize,
doc: i32,
_scorer: &mut S,
comparator: &mut Self::FieldComparator,
) -> Result<()>
where
S: Scorable + ?Sized,
{
match Self::get_value_for_doc(&mut self.doc_terms, doc)? {
None => comparator.values[slot] = None,
Some(value) => match comparator.values[slot].as_mut() {
Some(buffer) => {
buffer.copy_from_slice(value.as_bytes());
},
None => comparator.values[slot] = Some(value.into_owned()),
},
}
Ok(())
}
fn set_scorer<S>(
&mut self,
_scorer: &mut S,
_comparator: &mut Self::FieldComparator,
) -> Result<()>
where
S: Scorable + ?Sized,
{
Ok(())
}
type DocIdSetIteratorRef<'a>
= &'a mut DummyDISI
where
B: 'a;
}