use crate::core::codecs::doc_values_producer::DocValuesProducer;
use crate::core::codecs::{
CodecBinaryDocValues, CodecDocValuesProducer, CodecDocValuesSkipper, CodecNumericDocValues,
CodecSortedDocValues, CodecSortedNumericDocValues, CodecSortedSetDocValues,
};
use crate::core::index::doc_values_type::DocValuesType;
use crate::core::index::field_info::FieldInfo;
use crate::core::index::field_infos::FieldInfos;
use crate::core::index::segment_commit_info::SegmentCommitInfo;
use crate::core::index::segment_doc_values::SegmentDocValues;
use crate::core::store::directory::Directory;
use crate::core::store::index_input::IndexInput;
use crate::core::util::close::CloseableRef;
use crate::core::util::error::lucene_error::{CaughtResultExt, LuceneError, Result};
use std::collections::HashMap;
use std::fmt::{Display, Formatter};
use std::sync::Arc;
pub struct SegmentDocValuesProducer<I>
where
I: IndexInput,
{
dv_producers_by_field: HashMap<i32, usize>,
dv_producers: smallvec::SmallVec<[Arc<CodecDocValuesProducer<I>>; 2]>,
pub(crate) dv_gens: smallvec::SmallVec<[i64; 2]>,
}
impl<I> SegmentDocValuesProducer<I>
where
I: IndexInput,
{
pub(crate) fn new<D, D1>(
si: &SegmentCommitInfo<D>,
dir: Option<&D1>,
core_infos: &Arc<FieldInfos>,
all_infos: &FieldInfos,
seg_doc_values: &SegmentDocValues<I>,
) -> Result<Self>
where
D: Directory<IndexInput = I>,
D1: Directory<IndexInput = I>,
{
let mut num_dv_fields = 0;
let mut num_dv_gens = 0;
let mut has_base_producer = false;
for fi in all_infos {
if *fi.get_doc_values_type() != DocValuesType::None {
num_dv_fields += 1;
if fi.get_doc_values_gen() == -1 {
has_base_producer = true;
} else {
num_dv_gens += 1;
}
}
}
num_dv_gens += usize::from(has_base_producer);
let mut dv_producers_by_field = HashMap::with_capacity(num_dv_fields);
let mut dv_producers = smallvec::SmallVec::with_capacity(num_dv_gens);
let mut producer_indices = (num_dv_gens > 2).then(|| HashMap::with_capacity(num_dv_gens));
let mut dv_gens = smallvec::SmallVec::with_capacity(num_dv_gens);
let mut base_producer_index = None;
let mut result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
for fi in all_infos {
if *fi.get_doc_values_type() == DocValuesType::None {
continue;
}
let doc_values_gen = fi.get_doc_values_gen();
if doc_values_gen == -1 {
let producer_index = if let Some(producer_index) = base_producer_index {
producer_index
} else {
let producer = seg_doc_values.get_doc_values_producer(
doc_values_gen,
si,
dir,
core_infos.clone(),
)?;
dv_gens.push(doc_values_gen);
let producer_index =
Self::add_unique_producer(&mut dv_producers, &mut producer_indices, producer);
base_producer_index = Some(producer_index);
producer_index
};
dv_producers_by_field.insert(fi.number, producer_index);
} else {
debug_assert!(!dv_gens.contains(&doc_values_gen));
let field_infos = FieldInfos::new(vec![fi.clone()])?;
let dvp = seg_doc_values.get_doc_values_producer(doc_values_gen, si, dir, field_infos)?;
dv_gens.push(doc_values_gen);
let producer_index =
Self::add_unique_producer(&mut dv_producers, &mut producer_indices, dvp);
dv_producers_by_field.insert(fi.number, producer_index);
}
}
Ok(())
}));
if !matches!(&result, Ok(Ok(()))) {
let dec_ref_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
seg_doc_values.dec_ref(&dv_gens)
}));
result.add_suppressed(
dec_ref_result,
"panic while releasing doc values producers after initialization failure",
);
}
unwrap_caught_result!(result)?;
Ok(Self {
dv_producers_by_field,
dv_producers,
dv_gens,
})
}
fn add_unique_producer(
producers: &mut smallvec::SmallVec<[Arc<CodecDocValuesProducer<I>>; 2]>,
producer_indices: &mut Option<HashMap<*const CodecDocValuesProducer<I>, usize>>,
producer: Arc<CodecDocValuesProducer<I>>,
) -> usize {
let Some(producer_indices) = producer_indices else {
if let Some(index) = producers
.iter()
.position(|existing| Arc::ptr_eq(existing, &producer))
{
return index;
}
let index = producers.len();
producers.push(producer);
return index;
};
let identity = Arc::as_ptr(&producer);
match producer_indices.entry(identity) {
std::collections::hash_map::Entry::Occupied(entry) => *entry.get(),
std::collections::hash_map::Entry::Vacant(entry) => {
let producer_index = producers.len();
producers.push(producer);
entry.insert(producer_index);
producer_index
},
}
}
fn producer_for_field(&self, field: &FieldInfo) -> Result<&CodecDocValuesProducer<I>> {
let producer_index = self
.dv_producers_by_field
.get(&field.number)
.ok_or_else(|| {
LuceneError::illegal_state(format!(
"missing doc values producer for field {} ({})",
field.name, field.number
))
})?;
self
.dv_producers
.get(*producer_index)
.map(Arc::as_ref)
.ok_or_else(|| {
LuceneError::illegal_state(format!(
"invalid doc values producer index {producer_index} for field {} ({})",
field.name, field.number
))
})
}
}
impl<I> CloseableRef for SegmentDocValuesProducer<I>
where
I: IndexInput,
{
fn close(&self) -> Result<()> {
Err(LuceneError::unsupported_operation(""))
}
}
impl<I> DocValuesProducer for SegmentDocValuesProducer<I>
where
I: IndexInput,
{
type NumericDocValues = CodecNumericDocValues<I>;
fn get_numeric(&self, field: &Arc<FieldInfo>) -> Result<Self::NumericDocValues> {
self.producer_for_field(field)?.get_numeric(field)
}
type BinaryDocValues = CodecBinaryDocValues<I>;
fn get_binary(&self, field: &Arc<FieldInfo>) -> Result<Self::BinaryDocValues> {
self.producer_for_field(field)?.get_binary(field)
}
type SortedDocValues = CodecSortedDocValues<I>;
fn get_sorted(&self, field: &Arc<FieldInfo>) -> Result<Self::SortedDocValues> {
self.producer_for_field(field)?.get_sorted(field)
}
type SortedNumericDocValues = CodecSortedNumericDocValues<I>;
fn get_sorted_numeric(&self, field: &Arc<FieldInfo>) -> Result<Self::SortedNumericDocValues> {
self.producer_for_field(field)?.get_sorted_numeric(field)
}
type SortedSetDocValues = CodecSortedSetDocValues<I>;
fn get_sorted_set(&self, field: &Arc<FieldInfo>) -> Result<Self::SortedSetDocValues> {
self.producer_for_field(field)?.get_sorted_set(field)
}
type DocValuesSkipper = CodecDocValuesSkipper<I>;
fn get_skipper(&self, field: &Arc<FieldInfo>) -> Result<Option<Self::DocValuesSkipper>> {
self.producer_for_field(field)?.get_skipper(field)
}
fn check_integrity(&self) -> Result<()> {
for dv_producer in &self.dv_producers {
dv_producer.check_integrity()?;
}
Ok(())
}
}
impl<I> Display for SegmentDocValuesProducer<I>
where
I: IndexInput,
{
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(
f,
"SegmentDocValuesProducer (producers={})",
self.dv_producers.len()
)
}
}