use crate::core::codecs::codec::Codec;
use crate::core::codecs::live_docs_format::LiveDocsFormat;
use crate::core::index::segment_info::{SegmentInfo, named_for_this_segment, renamed_segment_file};
use crate::core::store::directory::Directory;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::core::util::{StringHelper, TryIntoInt};
use std::borrow::Cow;
use std::collections::{HashMap, HashSet};
use std::fmt::Write;
use std::sync::Arc;
use std::sync::atomic::{AtomicI64, Ordering};
pub struct SegmentCommitInfo<D> {
pub info: Arc<SegmentInfo<D>>,
id: Option<[u8; StringHelper::ID_LENGTH]>,
del_count: i32,
soft_del_count: i32,
del_gen: i64,
next_write_del_gen: i64,
field_infos_gen: i64,
next_write_field_infos_gen: i64,
doc_values_gen: i64,
next_write_doc_values_gen: i64,
dv_updates_files: Option<Arc<HashMap<i32, HashSet<String>>>>,
field_infos_files: Option<Arc<HashSet<String>>>,
size_in_bytes: AtomicI64,
buffered_deletes_gen: i64,
}
impl<D> SegmentCommitInfo<D> {
pub fn new<T>(
info: T,
del_count: i32,
soft_del_count: i32,
del_gen: i64,
field_infos_gen: i64,
doc_values_gen: i64,
id: Option<[u8; StringHelper::ID_LENGTH]>,
) -> Self
where
T: Into<Arc<SegmentInfo<D>>>,
{
Self {
info: info.into(),
del_count,
soft_del_count,
del_gen,
next_write_del_gen: if del_gen == -1 {
1
} else {
del_gen.wrapping_add(1)
},
field_infos_gen,
next_write_field_infos_gen: if field_infos_gen == -1 {
1
} else {
field_infos_gen.wrapping_add(1)
},
doc_values_gen,
next_write_doc_values_gen: if doc_values_gen == -1 {
1
} else {
doc_values_gen.wrapping_add(1)
},
id,
dv_updates_files: None,
field_infos_files: None,
size_in_bytes: AtomicI64::new(-1),
buffered_deletes_gen: -1,
}
}
pub fn get_doc_values_updates_files(&self) -> &HashMap<i32, HashSet<String>> {
static EMPTY: std::sync::LazyLock<HashMap<i32, HashSet<String>>> =
std::sync::LazyLock::new(HashMap::new);
self.dv_updates_files.as_deref().unwrap_or(&EMPTY)
}
pub(crate) fn take_doc_values_updates_files(&mut self) -> HashMap<i32, HashSet<String>> {
self
.dv_updates_files
.take()
.map(Arc::unwrap_or_clone)
.unwrap_or_default()
}
pub fn set_doc_values_updates_files<'a>(
&mut self,
dv_updates_files: Cow<'a, HashMap<i32, HashSet<String>>>,
) {
let old_files = self.dv_updates_files.take();
match dv_updates_files {
Cow::Borrowed(files) => {
if files.is_empty() {
return;
}
let mut renamed = old_files.and_then(Arc::into_inner).unwrap_or_default();
renamed.clear();
renamed.reserve(files.len());
let renamed = self.dv_updates_files.insert(Arc::new(renamed));
let renamed = Arc::make_mut(renamed);
for (key, file_set) in files {
let mut renamed_set = HashSet::with_capacity(file_set.len());
for file in file_set {
renamed_set.insert(renamed_segment_file(&self.info.name, file));
}
renamed.insert(*key, renamed_set);
}
},
Cow::Owned(mut files) => {
for file_set in files.values_mut() {
if file_set.iter().all(|file| {
let suffix = crate::core::index::IndexFileNames::strip_segment_name(file);
file.len() == self.info.name.len() + suffix.len()
&& file.starts_with(self.info.name.as_ref())
}) {
continue;
}
let previous_files = std::mem::replace(file_set, HashSet::with_capacity(file_set.len()));
for file in previous_files {
file_set.insert(named_for_this_segment(&self.info.name, file));
}
}
self.dv_updates_files = (!files.is_empty()).then(|| Arc::new(files));
},
}
}
pub(crate) fn set_imported_field_infos_files(&mut self, source: &HashSet<String>) {
self.set_field_infos_files(std::iter::empty::<String>());
if source.is_empty() {
return;
}
let files = self.field_infos_files.get_or_insert_with(Arc::default);
let files = Arc::make_mut(files);
files.reserve(source.len());
for file in source {
files.insert(renamed_segment_file(&self.info.name, file));
}
}
pub(crate) fn set_owned_field_infos_files(&mut self, files: HashSet<String>) {
if files.iter().all(|file| {
let suffix = crate::core::index::IndexFileNames::strip_segment_name(file);
file.len() == self.info.name.len() + suffix.len() && file.starts_with(self.info.name.as_ref())
}) {
self.field_infos_files = (!files.is_empty()).then(|| Arc::new(files));
} else {
self.set_field_infos_files(files);
}
}
pub fn get_field_infos_files(&self) -> &HashSet<String> {
static EMPTY: std::sync::LazyLock<HashSet<String>> = std::sync::LazyLock::new(HashSet::new);
self.field_infos_files.as_deref().unwrap_or(&EMPTY)
}
pub fn set_field_infos_files<I, S>(&mut self, field_infos_files: I)
where
I: IntoIterator<Item = S>,
S: AsRef<str> + Into<String>,
{
if let Some(current) = &mut self.field_infos_files {
if let Some(set) = Arc::get_mut(current) {
set.clear();
} else {
self.field_infos_files = None;
}
}
for file in field_infos_files {
let files = self.field_infos_files.get_or_insert_with(Arc::default);
Arc::make_mut(files).insert(named_for_this_segment(&self.info.name, file));
}
}
pub fn advance_del_gen(&mut self) {
self.del_gen = self.next_write_del_gen;
self.next_write_del_gen = self.del_gen.wrapping_add(1);
self.generation_advanced();
}
pub fn advance_next_write_del_gen(&mut self) {
self.next_write_del_gen = self.next_write_del_gen.wrapping_add(1);
}
pub fn get_next_write_del_gen(&self) -> i64 {
self.next_write_del_gen
}
pub fn set_next_write_del_gen(&mut self, v: i64) {
self.next_write_del_gen = v;
}
pub fn advance_field_infos_gen(&mut self) {
self.field_infos_gen = self.next_write_field_infos_gen;
self.next_write_field_infos_gen = self.field_infos_gen.wrapping_add(1);
self.generation_advanced();
}
pub fn advance_next_write_field_infos_gen(&mut self) {
self.next_write_field_infos_gen = self.next_write_field_infos_gen.wrapping_add(1);
}
pub fn get_next_write_field_infos_gen(&self) -> i64 {
self.next_write_field_infos_gen
}
pub fn set_next_write_field_infos_gen(&mut self, v: i64) {
self.next_write_field_infos_gen = v;
}
pub fn advance_doc_values_gen(&mut self) {
self.doc_values_gen = self.next_write_doc_values_gen;
self.next_write_doc_values_gen = self.doc_values_gen.wrapping_add(1);
self.generation_advanced();
}
pub fn advance_next_write_doc_values_gen(&mut self) {
self.next_write_doc_values_gen = self.next_write_doc_values_gen.wrapping_add(1);
}
pub fn get_next_write_doc_values_gen(&self) -> i64 {
self.next_write_doc_values_gen
}
pub fn set_next_write_doc_values_gen(&mut self, v: i64) {
self.next_write_doc_values_gen = v;
}
pub fn size_in_bytes(&self) -> Result<i64>
where
D: Directory,
{
let current_size = self.size_in_bytes.load(Ordering::SeqCst);
if current_size != -1 {
return Ok(current_size);
}
let mut sum = 0;
let files = self.files_for_read()?;
for file_name in files.iter() {
sum += self.info.dir.file_length(file_name)?;
}
let v: i64 = sum.try_convert()?;
self.size_in_bytes.store(v, Ordering::SeqCst);
Ok(v)
}
pub(crate) fn has_only_base_files(&self) -> bool {
!self.has_deletions()
&& self.get_field_infos_files().is_empty()
&& self
.dv_updates_files
.as_ref()
.is_none_or(|files| files.is_empty())
}
pub(crate) fn files_for_read(&self) -> Result<Cow<'_, HashSet<String>>> {
if self.has_only_base_files() {
Ok(Cow::Borrowed(self.info.files()?))
} else {
Ok(Cow::Owned(self.files()?))
}
}
pub(crate) fn append_files_to(&self, files: &mut HashSet<String>) -> Result<()> {
let info_files = self.info.files()?;
files.reserve(info_files.len() + self.update_file_count() + usize::from(self.has_deletions()));
files.extend(info_files.iter().cloned());
if self.has_deletions() {
self
.info
.get_codec()?
.live_docs_format()
.files(self, files)?;
}
self.append_update_files(files);
Ok(())
}
fn update_file_count(&self) -> usize {
self
.get_doc_values_updates_files()
.values()
.map(HashSet::len)
.sum::<usize>()
+ self.get_field_infos_files().len()
}
fn append_update_files(&self, files: &mut HashSet<String>) {
for update_files in self.get_doc_values_updates_files().values() {
files.extend(update_files.iter().cloned());
}
files.extend(self.get_field_infos_files().iter().cloned());
}
pub fn files(&self) -> Result<HashSet<String>> {
let mut files = HashSet::new();
self.append_files_to(&mut files)?;
Ok(files)
}
pub fn get_buffered_deletes_gen(&self) -> i64 {
self.buffered_deletes_gen
}
pub fn set_buffered_deletes_gen(&mut self, v: i64) -> Result<()> {
if self.buffered_deletes_gen == -1 {
self.buffered_deletes_gen = v;
self.generation_advanced();
Ok(())
} else {
Err(LuceneError::illegal_state(
"buffered deletes gen should only be set once",
))
}
}
pub fn has_deletions(&self) -> bool {
self.del_gen != -1
}
pub fn has_field_updates(&self) -> bool {
self.field_infos_gen != -1
}
pub fn get_next_field_infos_gen(&self) -> i64 {
self.next_write_field_infos_gen
}
pub fn get_field_infos_gen(&self) -> i64 {
self.field_infos_gen
}
pub fn get_next_doc_values_gen(&self) -> i64 {
self.next_write_doc_values_gen
}
pub fn get_doc_values_gen(&self) -> i64 {
self.doc_values_gen
}
pub fn get_next_del_gen(&self) -> i64 {
self.next_write_del_gen
}
pub fn get_del_gen(&self) -> i64 {
self.del_gen
}
pub fn get_del_count(&self) -> i32 {
self.del_count
}
pub fn get_soft_del_count(&self) -> i32 {
self.soft_del_count
}
pub fn set_del_count(&mut self, del_count: i32) -> Result<()> {
let max_doc = self.info.max_doc()?;
if del_count < 0 || del_count > max_doc {
return Err(LuceneError::illegal_argument(format!(
"invalid delCount={del_count} (maxDoc={max_doc})"
)));
}
debug_assert!(
self.soft_del_count + del_count <= max_doc,
"maxDoc={}, delCount={}, softDelCount={}",
max_doc,
del_count,
self.soft_del_count
);
self.del_count = del_count;
Ok(())
}
pub fn set_soft_del_count(&mut self, soft_del_count: i32) -> Result<()> {
let max_doc = self.info.max_doc()?;
validate_soft_del_count(self.del_count, max_doc, soft_del_count)?;
self.soft_del_count = soft_del_count;
Ok(())
}
pub fn set_soft_del_count_without_check(&mut self, soft_del_count: i32) {
self.soft_del_count = soft_del_count;
}
pub fn to_string_with_pending_del_count(
&self,
pending_del_count: i32,
) -> std::result::Result<String, std::fmt::Error> {
let mut description = String::new();
self.write_description(&mut description, pending_del_count)?;
Ok(description)
}
fn write_description(&self, output: &mut impl Write, pending_del_count: i32) -> std::fmt::Result {
self
.info
.write_description(output, self.del_count + pending_del_count)?;
if self.del_gen != -1 {
write!(output, ":delGen={}", self.del_gen)?;
}
if self.field_infos_gen != -1 {
write!(output, ":fieldInfosGen={}", self.field_infos_gen)?;
}
if self.doc_values_gen != -1 {
write!(output, ":dvGen={}", self.doc_values_gen)?;
}
if self.soft_del_count > 0 {
write!(output, " :softDel={}", self.soft_del_count)?;
}
if self.id.is_some() {
write!(
output,
" :id={}",
StringHelper::id_to_string(self.id.as_ref())
)?;
}
Ok(())
}
pub fn get_del_count_with_soft_deletes(&self, include_soft_deletes: bool) -> i32 {
if include_soft_deletes {
self.get_del_count() + self.get_soft_del_count()
} else {
self.get_del_count()
}
}
pub fn generation_advanced(&mut self) {
self.size_in_bytes.store(-1, Ordering::SeqCst);
self.id = Option::from(StringHelper::random_id());
}
pub fn get_id(&self) -> Option<&[u8; StringHelper::ID_LENGTH]> {
if self.id.is_none() {
None
} else {
self.id.as_ref()
}
}
}
pub fn validate_soft_del_count(del_count: i32, max_doc: i32, soft_del_count: i32) -> Result<()> {
if soft_del_count < 0 || soft_del_count > max_doc {
return Err(LuceneError::illegal_argument(format!(
"invalid softDelCount={soft_del_count} (maxDoc={max_doc})"
)));
}
debug_assert!(
del_count + soft_del_count <= max_doc,
"maxDoc={}, delCount={}, softDelCount={}",
max_doc,
del_count,
soft_del_count
);
Ok(())
}
impl<D> std::fmt::Display for SegmentCommitInfo<D> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.write_description(f, 0)
}
}
impl<D> Clone for SegmentCommitInfo<D> {
fn clone(&self) -> Self {
let mut other = SegmentCommitInfo::new(
self.info.clone(),
self.del_count,
self.soft_del_count,
self.del_gen,
self.field_infos_gen,
self.doc_values_gen,
self.get_id().copied(),
);
other.next_write_del_gen = self.next_write_del_gen;
other.next_write_field_infos_gen = self.next_write_field_infos_gen;
other.next_write_doc_values_gen = self.next_write_doc_values_gen;
other.dv_updates_files = self.dv_updates_files.clone();
other.field_infos_files = self.field_infos_files.clone();
other
}
}
impl<D> PartialEq for SegmentCommitInfo<D> {
fn eq(&self, other: &Self) -> bool {
std::ptr::eq(self, other)
}
}