pub(crate) use crate::core::codecs::block_term_state::TermStateEnum;
use crate::core::index::index_reader::Identity;
use crate::core::index::index_reader_context::IndexReaderContext;
use crate::core::index::leaf_reader::{LRTermsEnum, LeafReader};
use crate::core::index::leaf_reader_context::{LeafReaderContext, TopParentMeta};
use crate::core::index::term::Term;
use crate::core::index::term_state::TermState;
use crate::core::index::terms::Terms;
use crate::core::index::terms_enum::TermsEnum;
use crate::core::search::index_searcher::IndexSearcher;
use crate::core::search::similarities_impl::similarities::Similarity;
use crate::core::util::accountable::Accountable;
use crate::core::util::array_util::ArrayUtil;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::core::util::ram_usage_estimator::size_of_slice;
use std::fmt::{Display, Formatter};
use std::hash::{Hash, Hasher};
use std::sync::{Arc, LazyLock, OnceLock};
static EMPTY_TERM_STATE: LazyLock<Arc<TermStateEnum>> =
LazyLock::new(|| Arc::new(EmptyTermState.into()));
#[derive(Default)]
pub struct TermStates {
identity: Identity,
pub(crate) top_reader_context_identity: Identity,
states: smallvec::SmallVec<[OnceLock<Arc<TermStateEnum>>; 1]>,
term: Option<Arc<Term>>,
doc_freq: i32,
total_term_freq: i64,
}
impl TermStates {
pub fn with_term<IRC>(term: Option<Arc<Term>>, context: &IRC) -> Result<Self>
where
IRC: IndexReaderContext,
{
debug_assert!(context.base().is_top_level);
let num_leaves = context.leaves()?.len();
let mut states = smallvec::SmallVec::with_capacity(num_leaves);
for _ in 0..num_leaves {
states.push(OnceLock::new())
}
Ok(TermStates {
identity: Identity::new(),
top_reader_context_identity: context.base().identity.clone(),
doc_freq: 0,
total_term_freq: 0,
states,
term,
})
}
pub fn new<IRC>(context: &IRC) -> Result<Self>
where
IRC: IndexReaderContext,
{
Self::with_term(None, context)
}
pub fn was_built_for(&self, meta: &TopParentMeta) -> bool {
self.was_built_for_id(&meta.id)
}
pub fn was_built_for_id(&self, id: &Identity) -> bool {
self.top_reader_context_identity.eq(id)
}
pub fn with_state_and_stats<IRC>(
context: &IRC,
state: TermStateEnum,
ord: usize,
doc_freq: i32,
total_term_freq: i64,
) -> Result<Self>
where
IRC: IndexReaderContext,
{
let mut ts = TermStates::new(context)?;
ts.register_with_stats(state, ord, doc_freq, total_term_freq);
Ok(ts)
}
pub fn clear(&mut self) {
self.doc_freq = 0;
self.total_term_freq = 0;
for slot in self.states.iter_mut() {
slot.take();
}
}
pub fn register_with_stats(
&mut self,
state: TermStateEnum,
ord: usize,
doc_freq: i32,
total_term_freq: i64,
) {
self.register(state, ord);
self.accumulate_statistics(doc_freq, total_term_freq);
}
pub fn register<T>(&mut self, state: T, ord: usize)
where
T: Into<Arc<TermStateEnum>>,
{
debug_assert!(ord < self.states.len(), "ord {} out of bounds", ord);
debug_assert!(
self.states[ord].get().is_none(),
"state for ord: {ord} already registered"
);
self.states[ord] = OnceLock::from(state.into());
}
pub fn accumulate_statistics(&mut self, doc_freq: i32, total_term_freq: i64) {
debug_assert!(doc_freq >= 0);
debug_assert!(total_term_freq >= 0);
debug_assert!(
(doc_freq as i64) <= total_term_freq,
"doc_freq must not exceed total_term_freq"
);
self.doc_freq = self.doc_freq.wrapping_add(doc_freq);
self.total_term_freq = self.total_term_freq.wrapping_add(total_term_freq);
}
pub fn get<LR>(
&self,
ctx: &LeafReaderContext<LR>,
) -> Result<Option<PrepareState<LRTermsEnum<LR>>>>
where
LR: LeafReader,
{
let ctx_ord = ctx.ord;
if ctx_ord >= self.states.len() {
return Err(LuceneError::illegal_argument(format!(
"leaf ordinal {ctx_ord} is out of bounds for {} states",
self.states.len()
)));
}
let Some(term) = self.term.as_ref() else {
return Ok(if self.states[ctx_ord].get().is_none() {
None
} else {
Some(PrepareState::Ready(ctx_ord))
});
};
if self.states[ctx_ord].get().is_none() {
let Some(terms) = ctx.reader().terms(term.field())? else {
let _ = self.states[ctx_ord].set(Arc::clone(&EMPTY_TERM_STATE));
return Ok(None);
};
let mut te = terms.iterator()?;
let io_boolean_supplier = te.prepare_seek_exact(term.bytes())?;
if io_boolean_supplier.is_none() {
let _ = self.states[ctx_ord].set(Arc::clone(&EMPTY_TERM_STATE));
return Ok(None);
}
return Ok(Some(PrepareState::Pending(term.clone(), ctx_ord, te)));
}
let state = self.states[ctx_ord]
.get()
.ok_or_else(|| LuceneError::illegal_state("term state is missing"))?;
if matches!(state.as_ref(), TermStateEnum::Empty(_)) {
Ok(None)
} else {
Ok(Some(PrepareState::Ready(ctx_ord)))
}
}
pub fn resolve<TE>(&self, state: &mut PrepareState<TE>) -> Result<Option<&Arc<TermStateEnum>>>
where
TE: TermsEnum,
{
match state {
PrepareState::Ready(ord) => self.states.get(*ord).map(|slot| slot.get()).ok_or_else(|| {
LuceneError::illegal_argument(format!(
"leaf ordinal {ord} is out of bounds for {} states",
self.states.len()
))
}),
PrepareState::Pending(term, ord, te) => {
let state_count = self.states.len();
let state_slot = self.states.get(*ord).ok_or_else(|| {
LuceneError::illegal_argument(format!(
"leaf ordinal {ord} is out of bounds for {state_count} states"
))
})?;
if state_slot.get().is_none() {
let state = if te.get_prepare_seek_exact_status(term.bytes())? {
Arc::new(te.term_state()?)
} else {
Arc::clone(&EMPTY_TERM_STATE)
};
let _ = state_slot.set(state);
}
let state = state_slot
.get()
.ok_or_else(|| LuceneError::illegal_state("resolved term state is missing"))?;
if matches!(state.as_ref(), TermStateEnum::Empty(_)) {
Ok(None)
} else {
Ok(Some(state))
}
},
}
}
pub fn doc_freq(&self) -> Result<i32> {
if self.term.is_some() {
return Err(LuceneError::illegal_state(
"Cannot call docFreq() when needsStats=false",
));
}
Ok(self.doc_freq)
}
pub fn total_term_freq(&self) -> Result<i64> {
if self.term.is_some() {
return Err(LuceneError::illegal_state(
"Cannot call totalTermFreq() when needsStats=false",
));
}
Ok(self.total_term_freq)
}
}
impl Display for TermStates {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
writeln!(f, "TermStates")?;
for state in self.states.iter() {
writeln!(
f,
" state={}",
match state.get() {
None => "null".to_string(),
Some(s) => format!("{}", s),
}
)?;
}
Ok(())
}
}
impl PartialEq for TermStates {
fn eq(&self, other: &Self) -> bool {
self.identity == other.identity
}
}
impl Eq for TermStates {}
impl Hash for TermStates {
fn hash<H: Hasher>(&self, state: &mut H) {
self.identity.hash(state);
}
}
impl Accountable for TermStates {
fn ram_bytes_used(&self) -> Result<i64> {
let mut size = size_of_slice(&self.states);
for state in self.states.iter().filter_map(OnceLock::get) {
size = size.saturating_add(std::mem::size_of_val(state.as_ref()) as i64);
}
if let Some(term) = self.term.as_ref() {
size = size
.saturating_add(std::mem::size_of_val(term.as_ref()) as i64)
.saturating_add(term.ram_bytes_used()?);
}
Ok(size)
}
}
#[derive(Clone)]
pub struct EmptyTermState;
impl Display for EmptyTermState {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "TermState")
}
}
impl TermState for EmptyTermState {
fn copy_from(&mut self, _other: &Self) -> Result<()> {
Ok(())
}
}
pub enum PrepareState<TE> {
Ready(usize),
Pending(Arc<Term>, usize, TE),
}
pub fn build<IRC, T, SIM>(
index_searcher: &IndexSearcher<IRC, SIM>,
term: T,
needs_stats: bool,
) -> Result<TermStates>
where
SIM: Similarity,
IRC: IndexReaderContext,
T: Into<Arc<Term>>,
{
let term = term.into();
if needs_stats {
build_with_stats(index_searcher, &term)
} else {
TermStates::with_term(Some(term), index_searcher.get_top_reader_context())
}
}
pub(crate) fn build_with_stats<IRC, SIM>(
index_searcher: &IndexSearcher<IRC, SIM>,
term: &Term,
) -> Result<TermStates>
where
SIM: Similarity,
IRC: IndexReaderContext,
{
let context = index_searcher.get_top_reader_context();
let mut per_reader_term_state = TermStates::with_term(None, context)?;
let leaves = context.leaves()?;
let mut pending_term_lookups = Vec::new();
for ctx in leaves {
let terms = ctx.reader().terms(term.field())?;
match terms {
None => {
continue;
},
Some(t) => {
let mut terms_enum = t.iterator()?;
if terms_enum.prepare_seek_exact(term.bytes())?.is_some() {
if pending_term_lookups.capacity() == 0 {
pending_term_lookups.reserve_exact(leaves.len());
}
let ord = ctx.ord;
if pending_term_lookups.len() <= ord {
ArrayUtil::grow_with(&mut pending_term_lookups, ord + 1, || None)?;
}
pending_term_lookups[ord] = Some(terms_enum);
}
},
}
}
for (ord, mut pending) in pending_term_lookups.into_iter().enumerate() {
if let Some(ref mut terms_enum) = pending
&& terms_enum.get_prepare_seek_exact_status(term.bytes())?
{
per_reader_term_state.register_with_stats(
terms_enum.term_state()?,
ord,
terms_enum.doc_freq()?,
terms_enum.total_term_freq()?,
);
}
}
Ok(per_reader_term_state)
}