plug backward compat

quickwit-oss · trinity-1686a · Dec 4, 2023 · Nov 14, 2023 · Nov 15, 2023 · Nov 17, 2023
commit fd441da32d9201f040dd455d3c335281680aefba
diff --git a/sstable/src/dictionary.rs b/sstable/src/dictionary.rs
@@ -181,34  181,44 @@ impl<TSSTable: SSTable> Dictionary<TSSTable> {
 
     /// Opens a `TermDictionary`.
     pub fn open(term_dictionary_file: FileSlice) -> io::Result<Self> {
-        let (main_slice, footer_len_slice) = term_dictionary_file.split_from_end(28);
         let (main_slice, footer_len_slice) = term_dictionary_file.split_from_end(20);
         let mut footer_len_bytes: OwnedBytes = footer_len_slice.read_bytes()?;
-
-        let store_offset = u64::deserialize(&mut footer_len_bytes)?;
         let index_offset = u64::deserialize(&mut footer_len_bytes)?;
         let num_terms = u64::deserialize(&mut footer_len_bytes)?;
         let version = u32::deserialize(&mut footer_len_bytes)?;
-        if version != crate::SSTABLE_VERSION {
-            return Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!(
-                    "Unsuported sstable version, expected {version}, found {}",
-                    crate::SSTABLE_VERSION,
-                ),
-            ));
-        }
-
         let (sstable_slice, index_slice) = main_slice.split(index_offset as usize);
         let sstable_index_bytes = index_slice.read_bytes()?;
-        let sstable_index = if store_offset != 0 {
-            SSTableIndex::V3(
-                SSTableIndexV3::load(sstable_index_bytes, store_offset).map_err(|_| {
 
         let sstable_index = match version {
             2 => SSTableIndex::V2(
                 crate::sstable_index_v2::SSTableIndex::load(sstable_index_bytes).map_err(|_| {
                     io::Error::new(io::ErrorKind::InvalidData, "SSTable corruption")
                 })?,
-            )
-        } else {
-            SSTableIndex::V3Empty(SSTableIndexV3Empty::load(index_offset as usize))
             ),
             crate::SSTABLE_VERSION => {
                 let (sstable_index_bytes, mut footerv3_len_bytes) = sstable_index_bytes.rsplit(8);
                 let store_offset = u64::deserialize(&mut footerv3_len_bytes)?;
                 if store_offset != 0 {
                     SSTableIndex::V3(
                         SSTableIndexV3::load(sstable_index_bytes, store_offset).map_err(|_| {
                             io::Error::new(io::ErrorKind::InvalidData, "SSTable corruption")
                         })?,
                     )
                 } else {
                     SSTableIndex::V3Empty(SSTableIndexV3Empty::load(index_offset as usize))
                 }
             }
             _ => {
                 return Err(io::Error::new(
                     io::ErrorKind::Other,
                     format!(
                         "Unsuported sstable version, expected {}, found {version}",
                         crate::SSTABLE_VERSION,
                     ),
                 ))
             }
         };
 
         Ok(Dictionary {
             sstable_slice,
             sstable_index,

diff --git a/sstable/src/lib.rs b/sstable/src/lib.rs
@@ -12,6  12,7 @@ pub mod value;
 
 mod sstable_index;
 pub use sstable_index::{BlockAddr, SSTableIndex, SSTableIndexBuilder, SSTableIndexV3};
 mod sstable_index_v2;
 pub(crate) mod vint;
 pub use dictionary::Dictionary;
 pub use streamer::{Streamer, StreamerBuilder};

diff --git a/sstable/src/sstable_index.rs b/sstable/src/sstable_index.rs
@@ -11,7  11,7 @@ use crate::{common_prefix_len, SSTableDataCorruption, TermOrdinal};
 
 #[derive(Debug, Clone)]
 pub enum SSTableIndex {
-    V2,
     V2(crate::sstable_index_v2::SSTableIndex),
     V3(SSTableIndexV3),
     V3Empty(SSTableIndexV3Empty),
 }
@@ -20,7  20,7 @@ impl SSTableIndex {
     /// Get the [`BlockAddr`] of the requested block.
     pub(crate) fn get_block(&self, block_id: u64) -> Option<BlockAddr> {
         match self {
-            SSTableIndex::V2 => todo!(),
             SSTableIndex::V2(v2_index) => v2_index.get_block(block_id as usize),
             SSTableIndex::V3(v3_index) => v3_index.get_block(block_id),
             SSTableIndex::V3Empty(v3_empty) => v3_empty.get_block(block_id),
         }
@@ -31,7  31,7 @@ impl SSTableIndex {
     /// Returns None if `key` is lexicographically after the last key recorded.
     pub(crate) fn locate_with_key(&self, key: &[u8]) -> Option<u64> {
         match self {
-            SSTableIndex::V2 => todo!(),
             SSTableIndex::V2(v2_index) => v2_index.locate_with_key(key).map(|i| i as u64),
             SSTableIndex::V3(v3_index) => v3_index.locate_with_key(key),
             SSTableIndex::V3Empty(v3_empty) => v3_empty.locate_with_key(key),
         }
@@ -42,15  42,15 @@ impl SSTableIndex {
     /// Returns None if `key` is lexicographically after the last key recorded.
     pub fn get_block_with_key(&self, key: &[u8]) -> Option<BlockAddr> {
         match self {
-            SSTableIndex::V2 => todo!(),
             SSTableIndex::V2(v2_index) => v2_index.get_block_with_key(key),
             SSTableIndex::V3(v3_index) => v3_index.get_block_with_key(key),
             SSTableIndex::V3Empty(v3_empty) => v3_empty.get_block_with_key(key),
         }
     }
 
     pub(crate) fn locate_with_ord(&self, ord: TermOrdinal) -> u64 {
         match self {
-            SSTableIndex::V2 => todo!(),
             SSTableIndex::V2(v2_index) => v2_index.locate_with_ord(ord) as u64,
             SSTableIndex::V3(v3_index) => v3_index.locate_with_ord(ord),
             SSTableIndex::V3Empty(v3_empty) => v3_empty.locate_with_ord(ord),
         }
@@ -59,7  59,7 @@ impl SSTableIndex {
     /// Get the [`BlockAddr`] of the block containing the `ord`-th term.
     pub(crate) fn get_block_with_ord(&self, ord: TermOrdinal) -> BlockAddr {
         match self {
-            SSTableIndex::V2 => todo!(),
             SSTableIndex::V2(v2_index) => v2_index.get_block_with_ord(ord),
             SSTableIndex::V3(v3_index) => v3_index.get_block_with_ord(ord),
             SSTableIndex::V3Empty(v3_empty) => v3_empty.get_block_with_ord(ord),
         }

diff --git a/sstable/src/sstable_index_v2.rs b/sstable/src/sstable_index_v2.rs
@@ -0,0  1,101 @@
 use common::OwnedBytes;
 
 use crate::{BlockAddr, SSTable, SSTableDataCorruption, TermOrdinal};
 
 #[derive(Default, Debug, Clone)]
 pub struct SSTableIndex {
     blocks: Vec<BlockMeta>,
 }
 
 impl SSTableIndex {
     /// Load an index from its binary representation
     pub fn load(data: OwnedBytes) -> Result<SSTableIndex, SSTableDataCorruption> {
         let mut reader = IndexSSTable::reader(data);
         let mut blocks = Vec::new();
 
         while reader.advance().map_err(|_| SSTableDataCorruption)? {
             blocks.push(BlockMeta {
                 last_key_or_greater: reader.key().to_vec(),
                 block_addr: reader.value().clone(),
             });
         }
 
         Ok(SSTableIndex { blocks })
     }
 
     /// Get the [`BlockAddr`] of the requested block.
     pub(crate) fn get_block(&self, block_id: usize) -> Option<BlockAddr> {
         self.blocks
             .get(block_id)
             .map(|block_meta| block_meta.block_addr.clone())
     }
 
     /// Get the block id of the block that would contain `key`.
     ///
     /// Returns None if `key` is lexicographically after the last key recorded.
     pub(crate) fn locate_with_key(&self, key: &[u8]) -> Option<usize> {
         let pos = self
             .blocks
             .binary_search_by_key(&key, |block| &block.last_key_or_greater);
         match pos {
             Ok(pos) => Some(pos),
             Err(pos) => {
                 if pos < self.blocks.len() {
                     Some(pos)
                 } else {
                     // after end of last block: no block matches
                     None
                 }
             }
         }
     }
 
     /// Get the [`BlockAddr`] of the block that would contain `key`.
     ///
     /// Returns None if `key` is lexicographically after the last key recorded.
     pub fn get_block_with_key(&self, key: &[u8]) -> Option<BlockAddr> {
         self.locate_with_key(key).and_then(|id| self.get_block(id))
     }
 
     pub(crate) fn locate_with_ord(&self, ord: TermOrdinal) -> usize {
         let pos = self
             .blocks
             .binary_search_by_key(&ord, |block| block.block_addr.first_ordinal);
 
         match pos {
             Ok(pos) => pos,
             // Err(0) can't happen as the sstable starts with ordinal zero
             Err(pos) => pos - 1,
         }
     }
 
     /// Get the [`BlockAddr`] of the block containing the `ord`-th term.
     pub(crate) fn get_block_with_ord(&self, ord: TermOrdinal) -> BlockAddr {
         // locate_with_ord always returns an index within range
         self.get_block(self.locate_with_ord(ord)).unwrap()
     }
 }
 
 #[derive(Debug, Clone)]
 pub(crate) struct BlockMeta {
     /// Any byte string that is lexicographically greater or equal to
     /// the last key in the block,
     /// and yet strictly smaller than the first key in the next block.
     pub last_key_or_greater: Vec<u8>,
     pub block_addr: BlockAddr,
 }
 
 /// SSTable representing an index
 ///
 /// `last_key_or_greater` is used as the key, the value contains the
 /// length and first ordinal of each block. The start offset is implicitly
 /// obtained from lengths.
 struct IndexSSTable;
 
 impl SSTable for IndexSSTable {
     type Value = BlockAddr;
 
     type ValueReader = crate::value::index::IndexValueReader;
 
     type ValueWriter = crate::value::index::IndexValueWriter;
 }