use crate::core::codecs::DefaultStoredFieldsFormat;
use crate::core::codecs::stored_fields_format::StoredFieldsFormat;
use crate::core::codecs::stored_fields_reader::StoredFieldsReader;
use crate::core::index::codec_reader::CodecReader;
use crate::core::index::field_info::FieldInfo;
use crate::core::index::field_infos::FieldInfos;
use crate::core::index::merge_state::SharedDocMap;
use crate::core::index::merge_state::{DocMap, MergeState};
use crate::core::index::stored_field_visitor::{Status, StoredFieldVisitor};
use crate::core::index::stored_fields::StoredFields;
use crate::core::index::{BytesRef, DocIDMerger, Sub, SubBase, of};
use crate::core::search::doc_id_set_iterator::NO_MORE_DOCS;
use crate::core::store::DataInput;
use crate::core::store::directory::Directory;
use crate::core::util::access::ByteSource;
use crate::core::util::accountable::Accountable;
use crate::core::util::close::Closeable;
use crate::core::util::error::lucene_error::{LuceneError, Result};
pub trait StoredFieldsWriter: Accountable + Closeable {
fn start_document(&mut self) -> Result<()>;
fn finish_document(&mut self) -> Result<()> {
Ok(())
}
fn write_field_i32(&mut self, field_info: &FieldInfo, value: i32) -> Result<()>;
fn write_field_i64(&mut self, field_info: &FieldInfo, value: i64) -> Result<()>;
fn write_field_f32(&mut self, field_info: &FieldInfo, value: f32) -> Result<()>;
fn write_field_f64(&mut self, field_info: &FieldInfo, value: f64) -> Result<()>;
fn write_field_with_input<DI>(
&mut self,
field_info: &FieldInfo,
input: &mut DI,
length: usize,
) -> Result<()>
where
DI: DataInput,
{
if length == 0 {
let mut bytes = Vec::new();
input.read_bytes(&mut bytes, 0, 0)?;
return self.write_field_bytes(field_info, &BytesRef::from_slice(bytes, 0, 0));
}
let bytes = input.get_bytes(length)?;
self.write_field_bytes(
field_info,
&BytesRef {
bytes: bytes.as_ref(),
offset: 0,
length,
},
)
}
fn write_field_bytes<B>(&mut self, field_info: &FieldInfo, value: &BytesRef<B>) -> Result<()>
where
B: ByteSource;
fn write_field_str(&mut self, field_info: &FieldInfo, value: &str) -> Result<()>;
fn finish<D>(&mut self, num_docs: i32, dir: &D) -> Result<()>
where
D: Directory;
fn merge<D, D1, CR>(&mut self, merge_state: &mut MergeState<D, CR>, dir: &D1) -> Result<i32>
where
D1: Directory,
CR: CodecReader,
Self: Sized,
{
StoredFieldsWriterDefaults::merge(self, merge_state, dir)
}
}
pub struct StoredFieldsWriterDefaults;
impl StoredFieldsWriterDefaults {
pub fn merge<W, D, D1, CR>(
writer: &mut W,
merge_state: &mut MergeState<D, CR>,
dir: &D1,
) -> Result<i32>
where
W: StoredFieldsWriter,
D1: Directory,
CR: CodecReader,
{
let mut subs = Vec::with_capacity(merge_state.stored_fields_readers.len());
for i in 0..merge_state.stored_fields_readers.len() {
{
let reader = match merge_state.stored_fields_readers[i] {
Some(ref mut r) => r,
_ => {
return Err(LuceneError::illegal_state(
"Expected Lucene90CompressingStoredFieldsReader",
));
},
};
reader.check_integrity()?;
}
let visitor = MergeVisitor::new(
merge_state.merge_field_infos.as_ref(),
merge_state.field_infos[i].as_ref(),
)?;
subs.push(Sub::new(StoredFieldsMergeSub::new(
visitor,
merge_state.doc_map(i),
i,
merge_state.max_docs[i],
)));
}
let mut doc_count = 0;
let mut doc_id_merger = of(subs, merge_state.needs_index_sort)?;
while let Some(sub_idx) = doc_id_merger.next()? {
let sub = &mut doc_id_merger.get_subs_mut()[sub_idx];
debug_assert_eq!(sub.mapped_doc_id, doc_count);
writer.start_document()?;
let reader = match merge_state.stored_fields_readers[sub.sub.reader_index] {
Some(ref mut r) => r,
_ => {
return Err(LuceneError::illegal_state(
"Expected Lucene90CompressingStoredFieldsReader",
));
},
};
reader.document_with_visitor(sub.sub.doc_id, &mut sub.sub.visitor, Some(&mut *writer))?;
writer.finish_document()?;
doc_count += 1;
}
writer.finish(doc_count, dir)?;
Ok(doc_count)
}
}
pub type DefaultStoredFieldsWriter<D> =
<DefaultStoredFieldsFormat as StoredFieldsFormat>::StoredFieldsWriter<D>;
struct StoredFieldsMergeSub<'a, DM> {
pub reader_index: usize,
pub max_doc: i32,
pub visitor: MergeVisitor<'a>,
pub doc_id: i32,
pub doc_map: SharedDocMap<DM>,
}
impl<'a, DM> StoredFieldsMergeSub<'a, DM> {
fn new(
visitor: MergeVisitor<'a>,
doc_map: SharedDocMap<DM>,
reader_index: usize,
max_doc: i32,
) -> Self {
Self {
reader_index,
max_doc,
visitor,
doc_id: -1,
doc_map,
}
}
}
impl<DM> SubBase for StoredFieldsMergeSub<'_, DM>
where
DM: DocMap,
{
fn next_doc(&mut self) -> Result<i32> {
self.doc_id += 1;
if self.doc_id == self.max_doc {
Ok(NO_MORE_DOCS)
} else {
Ok(self.doc_id)
}
}
type DocMap = DM;
fn get_doc_map(&self) -> Result<&Self::DocMap> {
Ok(self.doc_map.as_ref())
}
}
#[derive(Default, Clone)]
pub(crate) struct MergeVisitor<'a> {
remapper: Option<&'a FieldInfos>,
}
impl<'a> MergeVisitor<'a> {
pub(crate) fn new(
merge_field_infos: &'a FieldInfos,
reader_field_infos: &FieldInfos,
) -> Result<Self> {
for fi in reader_field_infos {
match merge_field_infos.field_info_by_number(fi.number)? {
Some(other) if other.name == fi.name => {},
_ => {
return Ok(Self {
remapper: Some(merge_field_infos),
});
},
}
}
Ok(Self { remapper: None })
}
fn remap<'b>(&'b self, field: &'b FieldInfo) -> Result<&'b FieldInfo> {
if let Some(remapper) = self.remapper {
match remapper.field_info_by_name(&field.name)? {
Some(new_field) => Ok(new_field),
None => Err(LuceneError::illegal_state(format!(
"FieldInfo not found in remapper with filed_name: {}",
field.name
))),
}
} else {
Ok(field)
}
}
}
impl StoredFieldVisitor for MergeVisitor<'_> {
fn binary_field_with_input<S, DI>(
&mut self,
field_info: &FieldInfo,
input: &mut DI,
length: usize,
writer: Option<&mut S>,
) -> Result<()>
where
S: StoredFieldsWriter,
DI: DataInput,
{
let writer =
writer.ok_or_else(|| LuceneError::illegal_state("StoredFieldsWriter is required"))?;
writer.write_field_with_input(self.remap(field_info)?, input, length)
}
fn binary_field<S>(
&mut self,
field_info: &FieldInfo,
value: std::borrow::Cow<'_, [u8]>,
writer: Option<&mut S>,
) -> Result<()>
where
S: StoredFieldsWriter,
{
let writer =
writer.ok_or_else(|| LuceneError::illegal_state("StoredFieldsWriter is required"))?;
writer.write_field_bytes(
self.remap(field_info)?,
&BytesRef {
bytes: value.as_ref(),
offset: 0,
length: value.len(),
},
)
}
fn string_field<S>(
&mut self,
field_info: &FieldInfo,
value: std::borrow::Cow<'_, str>,
writer: Option<&mut S>,
) -> Result<()>
where
S: StoredFieldsWriter,
{
let writer =
writer.ok_or_else(|| LuceneError::illegal_state("StoredFieldsWriter is required"))?;
writer.write_field_str(self.remap(field_info)?, &value)
}
fn int_field<S>(
&mut self,
field_info: &FieldInfo,
value: i32,
writer: Option<&mut S>,
) -> Result<()>
where
S: StoredFieldsWriter,
{
let writer =
writer.ok_or_else(|| LuceneError::illegal_state("StoredFieldsWriter is required"))?;
writer.write_field_i32(self.remap(field_info)?, value)
}
fn long_field<S>(
&mut self,
field_info: &FieldInfo,
value: i64,
writer: Option<&mut S>,
) -> Result<()>
where
S: StoredFieldsWriter,
{
let writer =
writer.ok_or_else(|| LuceneError::illegal_state("StoredFieldsWriter is required"))?;
writer.write_field_i64(self.remap(field_info)?, value)
}
fn float_field<S>(
&mut self,
field_info: &FieldInfo,
value: f32,
writer: Option<&mut S>,
) -> Result<()>
where
S: StoredFieldsWriter,
{
let writer =
writer.ok_or_else(|| LuceneError::illegal_state("StoredFieldsWriter is required"))?;
writer.write_field_f32(self.remap(field_info)?, value)
}
fn double_field<S>(
&mut self,
field_info: &FieldInfo,
value: f64,
writer: Option<&mut S>,
) -> Result<()>
where
S: StoredFieldsWriter,
{
let writer =
writer.ok_or_else(|| LuceneError::illegal_state("StoredFieldsWriter is required"))?;
writer.write_field_f64(self.remap(field_info)?, value)
}
fn needs_field<S>(&mut self, _field_info: &FieldInfo, _writer: Option<&mut S>) -> Result<Status>
where
S: StoredFieldsWriter,
{
Ok(Status::Yes)
}
}
pub enum StoredFieldsWriterEnum2<A, B> {
A(A),
B(B),
}
impl<A, B> Closeable for StoredFieldsWriterEnum2<A, B>
where
A: Closeable,
B: Closeable,
{
fn close(&mut self) -> Result<()> {
match self {
Self::A(inner) => inner.close(),
Self::B(inner) => inner.close(),
}
}
}
impl<A, B> Accountable for StoredFieldsWriterEnum2<A, B>
where
A: Accountable,
B: Accountable,
{
fn ram_bytes_used(&self) -> Result<i64> {
match self {
Self::A(inner) => inner.ram_bytes_used(),
Self::B(inner) => inner.ram_bytes_used(),
}
}
}
impl<A, B> StoredFieldsWriter for StoredFieldsWriterEnum2<A, B>
where
A: StoredFieldsWriter,
B: StoredFieldsWriter,
{
fn start_document(&mut self) -> Result<()> {
match self {
Self::A(inner) => inner.start_document(),
Self::B(inner) => inner.start_document(),
}
}
fn finish_document(&mut self) -> Result<()> {
match self {
Self::A(inner) => inner.finish_document(),
Self::B(inner) => inner.finish_document(),
}
}
fn write_field_i32(&mut self, field_info: &FieldInfo, value: i32) -> Result<()> {
match self {
Self::A(inner) => inner.write_field_i32(field_info, value),
Self::B(inner) => inner.write_field_i32(field_info, value),
}
}
fn write_field_i64(&mut self, field_info: &FieldInfo, value: i64) -> Result<()> {
match self {
Self::A(inner) => inner.write_field_i64(field_info, value),
Self::B(inner) => inner.write_field_i64(field_info, value),
}
}
fn write_field_f32(&mut self, field_info: &FieldInfo, value: f32) -> Result<()> {
match self {
Self::A(inner) => inner.write_field_f32(field_info, value),
Self::B(inner) => inner.write_field_f32(field_info, value),
}
}
fn write_field_f64(&mut self, field_info: &FieldInfo, value: f64) -> Result<()> {
match self {
Self::A(inner) => inner.write_field_f64(field_info, value),
Self::B(inner) => inner.write_field_f64(field_info, value),
}
}
fn write_field_with_input<DI>(
&mut self,
field_info: &FieldInfo,
input: &mut DI,
length: usize,
) -> Result<()>
where
DI: DataInput,
{
match self {
Self::A(inner) => inner.write_field_with_input(field_info, input, length),
Self::B(inner) => inner.write_field_with_input(field_info, input, length),
}
}
fn write_field_bytes<S>(&mut self, field_info: &FieldInfo, value: &BytesRef<S>) -> Result<()>
where
S: ByteSource,
{
match self {
Self::A(inner) => inner.write_field_bytes(field_info, value),
Self::B(inner) => inner.write_field_bytes(field_info, value),
}
}
fn write_field_str(&mut self, field_info: &FieldInfo, value: &str) -> Result<()> {
match self {
Self::A(inner) => inner.write_field_str(field_info, value),
Self::B(inner) => inner.write_field_str(field_info, value),
}
}
fn finish<D>(&mut self, num_docs: i32, dir: &D) -> Result<()>
where
D: Directory,
{
match self {
Self::A(inner) => inner.finish(num_docs, dir),
Self::B(inner) => inner.finish(num_docs, dir),
}
}
fn merge<D, D1, CR>(&mut self, merge_state: &mut MergeState<D, CR>, dir: &D1) -> Result<i32>
where
D1: Directory,
CR: CodecReader,
{
match self {
Self::A(inner) => inner.merge(merge_state, dir),
Self::B(inner) => inner.merge(merge_state, dir),
}
}
}