use crate::core::codecs::mutable_point_tree::MutablePointTree;
use crate::core::index::index_reader::IndexReader;
use crate::core::index::index_reader_context::IndexReaderContext;
use crate::core::index::leaf_reader::LeafReader;
use crate::core::search::doc_id_set_iterator::DocIdSetIterator;
use crate::core::search::doc_id_set_iterator::NO_MORE_DOCS;
use crate::core::util::array_util::{ArrayUtil, ByteArrayComparator};
use crate::core::util::bkd::bkd_config::BKDConfig;
use crate::core::util::clone::TryClone;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::core::util::ints_ref::IntsRef;
use crate::core::util::{SliceCopyOps, TryIntoInt};
use std::borrow::Cow;
use std::sync::Arc;
pub trait PointValues {
fn get_min_packed_value(&self) -> Result<Option<Cow<'_, [u8]>>>;
fn get_max_packed_value(&self) -> Result<Option<Cow<'_, [u8]>>>;
fn get_num_dimensions(&self) -> Result<usize>;
fn get_num_index_dimensions(&self) -> Result<usize>;
fn get_bytes_per_dimension(&self) -> Result<usize>;
fn size(&self) -> Result<usize>;
fn get_doc_count(&self) -> Result<i32>;
type PointTree: PointTree;
fn get_point_tree(&self) -> Result<Self::PointTree>;
fn intersect<V>(&self, visitor: &mut V) -> Result<()>
where
V: IntersectVisitor,
{
let mut point_tree = self.get_point_tree()?;
intersect_with_point_tree(visitor, &mut point_tree)?;
debug_assert!(!point_tree.move_to_parent()?);
Ok(())
}
fn estimate_point_count<V>(&self, visitor: &V) -> Result<i64>
where
V: IntersectVisitor,
{
let mut point_tree = self.get_point_tree()?;
let count = estimate_point_count_with_point_tree(visitor, &mut point_tree, i64::MAX)?;
debug_assert!(!point_tree.move_to_parent()?);
Ok(count)
}
fn estimate_doc_count<V>(&self, visitor: &V) -> Result<i64>
where
V: IntersectVisitor,
{
let estimated_point_count = self.estimate_point_count(visitor)?;
let doc_count = self.get_doc_count()? as i64;
let size: i64 = self.size()?.try_convert()?;
if estimated_point_count >= size {
Ok(doc_count)
} else if size == doc_count || estimated_point_count == 0 {
Ok(estimated_point_count)
} else {
let doc_estimate = (doc_count as f64
* (1.0
- ((size - estimated_point_count) as f64 / size as f64)
.powf(size as f64 / doc_count as f64))) as i64;
Ok(if doc_estimate == 0 { 1 } else { doc_estimate })
}
}
}
pub fn size<IR>(reader: IR, field: &str) -> Result<i64>
where
IR: IndexReader,
{
let leaves = reader.get_context()?;
let leaves = leaves.leaves()?;
let mut size = 0_i64;
for leaf in leaves.iter() {
if let Some(values) = leaf.reader().get_point_values(field)? {
let v: i64 = values.size()?.try_convert()?;
size += v;
}
}
Ok(size)
}
pub fn get_doc_count<IR>(reader: IR, field: &str) -> Result<i32>
where
IR: IndexReader,
{
let leaves = reader.get_context()?;
let leaves = leaves.leaves()?;
let mut count = 0;
for leaf in leaves.iter() {
if let Some(values) = leaf.reader().get_point_values(field)? {
count += values.get_doc_count()?;
}
}
Ok(count)
}
pub fn get_min_packed_value<IR>(reader: IR, field: &str) -> Result<Option<Vec<u8>>>
where
IR: IndexReader,
{
let leaves = reader.get_context()?;
let leaves = leaves.leaves()?;
let mut min_value = None;
for leaf in leaves.iter() {
let values = match leaf.reader().get_point_values(field)? {
Some(v) => v,
None => continue,
};
let leaf_min_value = match values.get_min_packed_value()? {
Some(v) => v,
None => continue,
};
let min_value_ref = match min_value.as_mut() {
Some(min_value) => min_value,
None => {
min_value = Some(leaf_min_value.into_owned());
continue;
},
};
let num_dimensions = values.get_num_index_dimensions()?;
let num_bytes_per_dimension = values.get_bytes_per_dimension()?;
let comparator = ArrayUtil::get_unsigned_comparator(num_bytes_per_dimension);
for i in 0..num_dimensions {
let offset = i * num_bytes_per_dimension;
if comparator.compare(&leaf_min_value, offset, min_value_ref, offset) < 0 {
min_value_ref.copy_from(
&leaf_min_value[offset..offset + num_bytes_per_dimension],
offset,
);
}
}
}
Ok(min_value)
}
pub fn get_max_packed_value<IR>(reader: IR, field: &str) -> Result<Option<Vec<u8>>>
where
IR: IndexReader,
{
let ctx = reader.get_context()?;
let leaves = ctx.leaves()?;
let mut max_value: Option<Vec<u8>> = None;
for leaf in leaves.iter() {
let values = match leaf.reader().get_point_values(field)? {
Some(v) => v,
None => continue,
};
let leaf_max_value = match values.get_max_packed_value()? {
Some(v) => v,
None => continue,
};
let max_value_ref = match max_value.as_mut() {
Some(max_value) => max_value,
None => {
max_value = Some(leaf_max_value.into_owned());
continue;
},
};
let num_dimensions = values.get_num_index_dimensions()?;
let num_bytes_per_dimension = values.get_bytes_per_dimension()?;
let comparator = ArrayUtil::get_unsigned_comparator(num_bytes_per_dimension);
for dim in 0..num_dimensions {
let offset = dim * num_bytes_per_dimension;
if comparator.compare(&leaf_max_value, offset, max_value_ref, offset) > 0 {
max_value_ref.copy_from(
&leaf_max_value[offset..offset + num_bytes_per_dimension],
offset,
);
}
}
}
Ok(max_value)
}
pub(crate) fn is_estimated_point_count_greater_than_or_equal_to<V, T>(
visitor: &V,
point_tree: &mut T,
upper_bound: i64,
) -> Result<bool>
where
V: IntersectVisitor,
T: PointTree,
{
Ok(estimate_point_count_with_point_tree(visitor, point_tree, upper_bound)? >= upper_bound)
}
fn intersect_with_point_tree<V, T>(visitor: &mut V, point_tree: &mut T) -> Result<()>
where
V: IntersectVisitor,
T: PointTree,
{
let relation = visitor.compare(
point_tree.get_min_packed_value()?.as_ref(),
point_tree.get_max_packed_value()?.as_ref(),
)?;
match relation {
Relation::CellOutsideQuery => {
},
Relation::CellInsideQuery => {
point_tree.visit_doc_ids(visitor)?;
},
Relation::CellCrossesQuery => {
if point_tree.move_to_child()? {
loop {
intersect_with_point_tree(visitor, point_tree)?;
if !point_tree.move_to_sibling()? {
break;
}
}
point_tree.move_to_parent()?;
} else {
point_tree.visit_doc_values(visitor)?;
}
},
}
Ok(())
}
fn estimate_point_count_with_point_tree<V, T>(
visitor: &V,
point_tree: &mut T,
upper_bound: i64,
) -> Result<i64>
where
V: IntersectVisitor,
T: PointTree,
{
let relation = visitor.compare(
point_tree.get_min_packed_value()?.as_ref(),
point_tree.get_max_packed_value()?.as_ref(),
)?;
match relation {
Relation::CellOutsideQuery => {
Ok(0)
},
Relation::CellInsideQuery => {
Ok(point_tree.size()?.try_convert()?)
},
Relation::CellCrossesQuery => {
if point_tree.move_to_child()? {
let mut cost = 0;
loop {
cost += estimate_point_count_with_point_tree(visitor, point_tree, upper_bound - cost)?;
if cost >= upper_bound || !point_tree.move_to_sibling()? {
break;
}
}
point_tree.move_to_parent()?;
Ok(cost)
} else {
let v: i64 = point_tree.size()?.try_convert()?;
Ok((v + 1) / 2)
}
},
}
}
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum Relation {
CellInsideQuery,
CellOutsideQuery,
CellCrossesQuery,
}
impl Relation {
pub fn ordinal(&self) -> i32 {
match self {
Relation::CellInsideQuery => 0,
Relation::CellOutsideQuery => 1,
Relation::CellCrossesQuery => 2,
}
}
}
pub trait PointTree: TryClone {
type MutablePointTree: MutablePointTree;
fn move_to_child(&mut self) -> Result<bool> {
Err(LuceneError::need_implemented("move_to_child not implement"))
}
fn move_to_sibling(&mut self) -> Result<bool> {
Err(LuceneError::need_implemented(
"move_to_sibling not implement",
))
}
fn move_to_parent(&mut self) -> Result<bool> {
Err(LuceneError::need_implemented(
"move_to_parent not implement",
))
}
fn get_min_packed_value(&self) -> Result<Cow<'_, [u8]>> {
Err(LuceneError::need_implemented(
"get_min_packed_value not implement",
))
}
fn get_max_packed_value(&self) -> Result<Cow<'_, [u8]>> {
Err(LuceneError::need_implemented(
"get_max_packed_value not implement",
))
}
fn size(&self) -> Result<usize> {
Err(LuceneError::need_implemented("size not implement"))
}
fn visit_doc_ids<IV>(&mut self, _visitor: &mut IV) -> Result<()>
where
IV: IntersectVisitor,
{
Err(LuceneError::need_implemented("visit_doc_ids not implement"))
}
fn visit_doc_values<IV>(&mut self, _visitor: &mut IV) -> Result<()>
where
IV: IntersectVisitor,
{
Err(LuceneError::need_implemented(
"visit_doc_values not implement",
))
}
fn into_mutable(self) -> PointTreeEnum<Self::MutablePointTree, Self>
where
Self: Sized,
{
PointTreeEnum::Other(self)
}
}
pub trait IntersectVisitor {
fn visit(&mut self, doc_id: i32) -> Result<()>;
fn visit_with_iterator<I>(&mut self, iterator: &mut I) -> Result<()>
where
I: DocIdSetIterator,
{
loop {
let doc_id = iterator.next_doc()?;
if doc_id == NO_MORE_DOCS {
break;
}
self.visit(doc_id)?;
}
Ok(())
}
fn visit_with_ints_ref(&mut self, ints_ref: &IntsRef<Vec<i32>>) -> Result<()> {
self.default_visit_with_ints_ref(ints_ref)
}
fn default_visit_with_ints_ref(&mut self, ints_ref: &IntsRef<Vec<i32>>) -> Result<()> {
for i in ints_ref.offset..(ints_ref.offset + ints_ref.length) {
self.visit(ints_ref.ints[i])?;
}
Ok(())
}
fn visit_with_packed_value(&mut self, doc_id: i32, packed_value: &[u8]) -> Result<()>;
fn visit_iterator_with_packed_value<I>(
&mut self,
iterator: &mut I,
packed_value: &[u8],
) -> Result<()>
where
I: DocIdSetIterator,
{
self.default_visit_iterator_with_packed_value_(iterator, packed_value)
}
fn default_visit_iterator_with_packed_value_<I>(
&mut self,
iterator: &mut I,
packed_value: &[u8],
) -> Result<()>
where
I: DocIdSetIterator,
{
loop {
let doc_id = iterator.next_doc()?;
if doc_id == NO_MORE_DOCS {
break;
}
self.visit_with_packed_value(doc_id, packed_value)?;
}
Ok(())
}
fn compare(&self, min_packed_value: &[u8], max_packed_value: &[u8]) -> Result<Relation>;
fn grow(&mut self, _count: usize) -> Result<()> {
Ok(())
}
}
pub const MAX_NUM_BYTES: usize = 16;
pub const MAX_DIMENSIONS: usize = BKDConfig::MAX_DIMS;
pub const MAX_INDEX_DIMENSIONS: usize = BKDConfig::MAX_INDEX_DIMS;
pub enum PointTreeEnum<M, O> {
Mutable(M),
Other(O),
}
impl<M, O> TryClone for PointTreeEnum<M, O>
where
M: MutablePointTree,
O: PointTree,
{
fn try_clone(&self) -> Result<Self>
where
Self: Sized,
{
match self {
PointTreeEnum::Mutable(mpt) => Ok(PointTreeEnum::Mutable(mpt.try_clone()?)),
PointTreeEnum::Other(pt) => Ok(PointTreeEnum::Other(pt.try_clone()?)),
}
}
}
impl<M, O> PointTree for PointTreeEnum<M, O>
where
M: MutablePointTree,
O: PointTree,
{
type MutablePointTree = M;
fn into_mutable(self) -> PointTreeEnum<Self::MutablePointTree, Self> {
match self {
Self::Mutable(tree) => PointTreeEnum::Mutable(tree),
Self::Other(tree) => PointTreeEnum::Other(Self::Other(tree)),
}
}
fn move_to_child(&mut self) -> Result<bool> {
match self {
PointTreeEnum::Mutable(mpt) => mpt.move_to_child(),
PointTreeEnum::Other(pt) => pt.move_to_child(),
}
}
fn move_to_sibling(&mut self) -> Result<bool> {
match self {
PointTreeEnum::Mutable(mpt) => mpt.move_to_sibling(),
PointTreeEnum::Other(pt) => pt.move_to_sibling(),
}
}
fn move_to_parent(&mut self) -> Result<bool> {
match self {
PointTreeEnum::Mutable(mpt) => mpt.move_to_parent(),
PointTreeEnum::Other(pt) => pt.move_to_parent(),
}
}
fn get_min_packed_value(&self) -> Result<Cow<'_, [u8]>> {
match self {
PointTreeEnum::Mutable(mpt) => mpt.get_min_packed_value(),
PointTreeEnum::Other(pt) => pt.get_min_packed_value(),
}
}
fn get_max_packed_value(&self) -> Result<Cow<'_, [u8]>> {
match self {
PointTreeEnum::Mutable(mpt) => mpt.get_max_packed_value(),
PointTreeEnum::Other(pt) => pt.get_max_packed_value(),
}
}
fn size(&self) -> Result<usize> {
match self {
PointTreeEnum::Mutable(mpt) => mpt.size(),
PointTreeEnum::Other(pt) => pt.size(),
}
}
fn visit_doc_ids<IV>(&mut self, _visitor: &mut IV) -> Result<()>
where
IV: IntersectVisitor,
{
match self {
PointTreeEnum::Mutable(mpt) => mpt.visit_doc_ids(_visitor),
PointTreeEnum::Other(pt) => pt.visit_doc_ids(_visitor),
}
}
fn visit_doc_values<IV>(&mut self, _visitor: &mut IV) -> Result<()>
where
IV: IntersectVisitor,
{
match self {
PointTreeEnum::Mutable(mpt) => mpt.visit_doc_values(_visitor),
PointTreeEnum::Other(pt) => pt.visit_doc_values(_visitor),
}
}
}
pub enum PointTreeEnum2<A, B> {
A(A),
B(B),
}
impl<A, B> TryClone for PointTreeEnum2<A, B>
where
A: PointTree,
B: PointTree,
{
fn try_clone(&self) -> Result<Self>
where
Self: Sized,
{
match self {
PointTreeEnum2::A(tree) => Ok(PointTreeEnum2::A(tree.try_clone()?)),
PointTreeEnum2::B(tree) => Ok(PointTreeEnum2::B(tree.try_clone()?)),
}
}
}
impl<A, B> PointTree for PointTreeEnum2<A, B>
where
A: PointTree,
B: PointTree,
{
type MutablePointTree =
crate::core::codecs::dummy::dummy_mutable_point_tree::DummyMutablePointTree;
fn move_to_child(&mut self) -> Result<bool> {
match self {
PointTreeEnum2::A(tree) => tree.move_to_child(),
PointTreeEnum2::B(tree) => tree.move_to_child(),
}
}
fn move_to_sibling(&mut self) -> Result<bool> {
match self {
PointTreeEnum2::A(tree) => tree.move_to_sibling(),
PointTreeEnum2::B(tree) => tree.move_to_sibling(),
}
}
fn move_to_parent(&mut self) -> Result<bool> {
match self {
PointTreeEnum2::A(tree) => tree.move_to_parent(),
PointTreeEnum2::B(tree) => tree.move_to_parent(),
}
}
fn get_min_packed_value(&self) -> Result<Cow<'_, [u8]>> {
match self {
PointTreeEnum2::A(tree) => tree.get_min_packed_value(),
PointTreeEnum2::B(tree) => tree.get_min_packed_value(),
}
}
fn get_max_packed_value(&self) -> Result<Cow<'_, [u8]>> {
match self {
PointTreeEnum2::A(tree) => tree.get_max_packed_value(),
PointTreeEnum2::B(tree) => tree.get_max_packed_value(),
}
}
fn size(&self) -> Result<usize> {
match self {
PointTreeEnum2::A(tree) => tree.size(),
PointTreeEnum2::B(tree) => tree.size(),
}
}
fn visit_doc_ids<IV>(&mut self, visitor: &mut IV) -> Result<()>
where
IV: IntersectVisitor,
{
match self {
PointTreeEnum2::A(tree) => tree.visit_doc_ids(visitor),
PointTreeEnum2::B(tree) => tree.visit_doc_ids(visitor),
}
}
fn visit_doc_values<IV>(&mut self, visitor: &mut IV) -> Result<()>
where
IV: IntersectVisitor,
{
match self {
PointTreeEnum2::A(tree) => tree.visit_doc_values(visitor),
PointTreeEnum2::B(tree) => tree.visit_doc_values(visitor),
}
}
}
impl<T> PointValues for Arc<T>
where
T: PointValues,
{
fn get_min_packed_value(&self) -> Result<Option<Cow<'_, [u8]>>> {
(**self).get_min_packed_value()
}
fn get_max_packed_value(&self) -> Result<Option<Cow<'_, [u8]>>> {
(**self).get_max_packed_value()
}
fn get_num_dimensions(&self) -> Result<usize> {
(**self).get_num_dimensions()
}
fn get_num_index_dimensions(&self) -> Result<usize> {
(**self).get_num_index_dimensions()
}
fn get_bytes_per_dimension(&self) -> Result<usize> {
(**self).get_bytes_per_dimension()
}
fn size(&self) -> Result<usize> {
(**self).size()
}
fn get_doc_count(&self) -> Result<i32> {
(**self).get_doc_count()
}
type PointTree = T::PointTree;
fn get_point_tree(&self) -> Result<Self::PointTree> {
(**self).get_point_tree()
}
fn intersect<V>(&self, visitor: &mut V) -> Result<()>
where
V: IntersectVisitor,
{
(**self).intersect(visitor)
}
fn estimate_point_count<V>(&self, visitor: &V) -> Result<i64>
where
V: IntersectVisitor,
{
(**self).estimate_point_count(visitor)
}
fn estimate_doc_count<V>(&self, visitor: &V) -> Result<i64>
where
V: IntersectVisitor,
{
(**self).estimate_doc_count(visitor)
}
}