Compare ⋅ tglman/persy

No flags found

Use flags to group coverage reports by test type, project and/or folders.
Then setup custom commit statuses and notifications for each flag.

e.g., #unittest #integration

#production #enterprise

#frontend #backend

Learn more about Codecov Flags here.

Showing 3 of 3 files from the diff.

94.59% 80.00% -0.18%

src/discref.rs changed.

98.09% 100.00% +0.47%

src/io.rs changed.

92.61% 97.83% -0.18%

src/journal.rs changed.

@@ -122,6 +122,13 @@

Loading

    fn is_free(&self) -> PRes<bool> {
        Ok((self.buff[1] & 0b1000_0000) != 0)
    }
    fn cursor_pos(&self) -> usize {
        if self.pos >= 2 {
            self.pos - 2
        } else {
            0
        }
    }
}

#[derive(Clone)]

@@ -139,6 +146,7 @@

Loading

    fn clone_read(&self) -> ReadPage;
    fn clone_write(&self) -> Page;
    fn is_free(&self) -> PRes<bool>;
    fn cursor_pos(&self) -> usize;
}

fn free_flag_set(mut cur: u8, free: bool) -> u8 {

@@ -226,6 +234,13 @@

Loading

    fn is_free(&self) -> PRes<bool> {
        Ok(is_free(self.buff[1]))
    }
    fn cursor_pos(&self) -> usize {
        if self.pos >= 2 {
            self.pos - 2
        } else {
            0
        }
    }
}

impl Page {

@@ -33,53 +33,53 @@

Loading


pub(crate) trait InfallibleReadVarInt: InfallibleRead {
    #[inline]
    fn read_u8_varint(&mut self) -> u8 {
    fn read_varint_u8(&mut self) -> u8 {
        io::read_u8(InfallibleReadWrapper::new(self)).expect("infallible")
    }

    #[inline]
    fn read_u16_varint(&mut self) -> u16 {
    fn read_varint_u16(&mut self) -> u16 {
        io::read_u16(InfallibleReadWrapper::new(self)).expect("infallible")
    }

    #[inline]
    fn read_u32_varint(&mut self) -> u32 {
    fn read_varint_u32(&mut self) -> u32 {
        io::read_u32(InfallibleReadWrapper::new(self)).expect("infallible")
    }

    #[inline]
    fn read_u64_varint(&mut self) -> u64 {
    fn read_varint_u64(&mut self) -> u64 {
        io::read_u64(InfallibleReadWrapper::new(self)).expect("infallible")
    }

    #[inline]
    fn read_u128_varint(&mut self) -> u128 {
    fn read_varint_u128(&mut self) -> u128 {
        io::read_u128(InfallibleReadWrapper::new(self)).expect("infallible")
    }

    #[inline]
    fn read_i8_varint(&mut self) -> i8 {
        ZigZag::decode(self.read_u8_varint())
    fn read_varint_i8(&mut self) -> i8 {
        ZigZag::decode(self.read_varint_u8())
    }

    #[inline]
    fn read_i16_varint(&mut self) -> i16 {
        ZigZag::decode(self.read_u16_varint())
    fn read_varint_i16(&mut self) -> i16 {
        ZigZag::decode(self.read_varint_u16())
    }

    #[inline]
    fn read_i32_varint(&mut self) -> i32 {
        ZigZag::decode(self.read_u32_varint())
    fn read_varint_i32(&mut self) -> i32 {
        ZigZag::decode(self.read_varint_u32())
    }

    #[inline]
    fn read_i64_varint(&mut self) -> i64 {
        ZigZag::decode(self.read_u64_varint())
    fn read_varint_i64(&mut self) -> i64 {
        ZigZag::decode(self.read_varint_u64())
    }

    #[inline]
    fn read_i128_varint(&mut self) -> i128 {
        ZigZag::decode(self.read_u128_varint())
    fn read_varint_i128(&mut self) -> i128 {
        ZigZag::decode(self.read_varint_u128())
    }
}
impl<R: InfallibleRead + ?Sized> InfallibleReadVarInt for R {}

@@ -8,7 +8,10 @@

Loading

    discref::{Page, PageOps, ReadPage, PAGE_METADATA_SIZE},
    error::PRes,
    flush_checksum::{double_buffer_check, prepare_buffer_flush},
    io::{read_u64, write_u64, InfallibleRead, InfallibleReadFormat, InfallibleWrite, InfallibleWriteFormat},
    io::{
        read_u64, write_u64, InfallibleRead, InfallibleReadFormat, InfallibleReadVarInt, InfallibleWrite,
        InfallibleWriteFormat, InfallibleWriteVarInt,
    },
    persy::RecoverStatus,
};
use std::{

@@ -102,7 +105,7 @@

Loading

pub(crate) trait JournalEntry {
    fn get_type(&self) -> u8;
    fn write(&self, buffer: &mut dyn InfallibleWrite) -> PRes<()>;
    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<u32>;
    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<()>;
    fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus>;
}


@@ -114,13 +117,13 @@

Loading

    pos: u32,
}

fn recover_entry<T>(entry: &mut dyn JournalEntry, page: &mut ReadPage, found: &mut T, id: &JournalId) -> PRes<u32>
fn recover_entry<T>(entry: &mut dyn JournalEntry, page: &mut ReadPage, found: &mut T, id: &JournalId) -> PRes<()>
where
    T: FnMut(&dyn JournalEntry, &JournalId),
{
    let read_size = entry.read(page)?;
    entry.read(page)?;
    found(entry, id);
    Ok(read_size)
    Ok(())
}

impl Journal {

@@ -316,20 +319,21 @@

Loading

        let mut cur_page = jr.first_page;
        jr.last_page = jr.first_page;
        journal_pages.push(cur_page);
        let mut cur_cursor = JOURNAL_PAGE_CONTENT_OFFSET;
        let mut page = self.allocator.load_page(cur_page)?;
        page.seek(JOURNAL_PAGE_CONTENT_OFFSET)?;
        loop {
            let mut page = self.allocator.load_page(cur_page)?;
            page.seek(cur_cursor)?;
            let tp = page.read_u8();
            if tp == 0 {
                let last_pos = page.cursor_pos() as u32;
                page.seek(JOURNAL_PAGE_NEXT_OFFSET)?;
                cur_page = page.read_u64();
                if cur_page == 0 {
                    jr.last_pos = cur_cursor;
                    jr.last_pos = last_pos - 1;
                    break;
                }
                journal_pages.push(cur_page);
                cur_cursor = JOURNAL_PAGE_CONTENT_OFFSET;
                page = self.allocator.load_page(cur_page)?;
                page.seek(JOURNAL_PAGE_CONTENT_OFFSET)?;
                jr.last_page = cur_page;
            } else {
                let page_id = page.read_u64();

@@ -337,7 +341,7 @@

Loading

                let id = JournalId::new(page_id, pos);
                let ref_page = &mut page;
                let ref_found = &mut found;
                let read_size = match tp {
                match tp {
                    //The Start entry has no valid id, should not be recovered
                    1 => Start::new().read(&mut page)?,
                    2 => recover_entry(&mut InsertRecord::default(), ref_page, ref_found, &id)?,

@@ -355,7 +359,6 @@

Loading

                    14 => recover_entry(&mut Cleanup::default(), ref_page, ref_found, &id)?,
                    _ => panic!(" wrong log entry {} ", tp),
                };
                cur_cursor = read_size + cur_cursor + 13;
            }
        }
        jr.current = self.allocator.write_page(jr.last_page)?;

@@ -393,19 +396,19 @@

Loading

    }

    fn write(&self, buffer: &mut dyn InfallibleWrite) -> PRes<()> {
        buffer.write_u32(self.segment);
        buffer.write_u64(self.recref.page);
        buffer.write_u32(self.recref.pos);
        buffer.write_u16(self.version);
        buffer.write_varint_u32(self.segment);
        buffer.write_varint_u64(self.recref.page);
        buffer.write_varint_u32(self.recref.pos);
        buffer.write_varint_u16(self.version);
        Ok(())
    }

    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<u32> {
        self.segment = buffer.read_u32();
        self.recref.page = buffer.read_u64();
        self.recref.pos = buffer.read_u32();
        self.version = buffer.read_u16();
        Ok(18)
    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<()> {
        self.segment = buffer.read_varint_u32();
        self.recref.page = buffer.read_varint_u64();
        self.recref.pos = buffer.read_varint_u32();
        self.version = buffer.read_varint_u16();
        Ok(())
    }

    fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus> {

@@ -420,19 +423,19 @@

Loading

    }

    fn write(&self, buffer: &mut dyn InfallibleWrite) -> PRes<()> {
        buffer.write_u32(self.segment);
        buffer.write_u64(self.recref.page);
        buffer.write_u32(self.recref.pos);
        buffer.write_u16(self.version);
        buffer.write_varint_u32(self.segment);
        buffer.write_varint_u64(self.recref.page);
        buffer.write_varint_u32(self.recref.pos);
        buffer.write_varint_u16(self.version);
        Ok(())
    }

    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<u32> {
        self.segment = buffer.read_u32();
        self.recref.page = buffer.read_u64();
        self.recref.pos = buffer.read_u32();
        self.version = buffer.read_u16();
        Ok(18)
    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<()> {
        self.segment = buffer.read_varint_u32();
        self.recref.page = buffer.read_varint_u64();
        self.recref.pos = buffer.read_varint_u32();
        self.version = buffer.read_varint_u16();
        Ok(())
    }

    fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus> {

@@ -446,21 +449,21 @@

Loading

    }

    fn write(&self, buffer: &mut dyn InfallibleWrite) -> PRes<()> {
        buffer.write_u32(self.segment);
        buffer.write_u64(self.recref.page);
        buffer.write_u32(self.recref.pos);
        buffer.write_u64(self.record_page);
        buffer.write_u16(self.version);
        buffer.write_varint_u32(self.segment);
        buffer.write_varint_u64(self.recref.page);
        buffer.write_varint_u32(self.recref.pos);
        buffer.write_varint_u64(self.record_page);
        buffer.write_varint_u16(self.version);
        Ok(())
    }

    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<u32> {
        self.segment = buffer.read_u32();
        self.recref.page = buffer.read_u64();
        self.recref.pos = buffer.read_u32();
        self.record_page = buffer.read_u64();
        self.version = buffer.read_u16();
        Ok(26)
    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<()> {
        self.segment = buffer.read_varint_u32();
        self.recref.page = buffer.read_varint_u64();
        self.recref.pos = buffer.read_varint_u32();
        self.record_page = buffer.read_varint_u64();
        self.version = buffer.read_varint_u16();
        Ok(())
    }

    fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus> {

@@ -475,19 +478,19 @@

Loading

    }

    fn write(&self, buffer: &mut dyn InfallibleWrite) -> PRes<()> {
        buffer.write_u32(self.segment);
        buffer.write_u64(self.recref.page);
        buffer.write_u32(self.recref.pos);
        buffer.write_u64(self.record_page);
        buffer.write_varint_u32(self.segment);
        buffer.write_varint_u64(self.recref.page);
        buffer.write_varint_u32(self.recref.pos);
        buffer.write_varint_u64(self.record_page);
        Ok(())
    }

    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<u32> {
        self.segment = buffer.read_u32();
        self.recref.page = buffer.read_u64();
        self.recref.pos = buffer.read_u32();
        self.record_page = buffer.read_u64();
        Ok(24)
    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<()> {
        self.segment = buffer.read_varint_u32();
        self.recref.page = buffer.read_varint_u64();
        self.recref.pos = buffer.read_varint_u32();
        self.record_page = buffer.read_varint_u64();
        Ok(())
    }

    fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus> {

@@ -505,8 +508,8 @@

Loading

        Ok(())
    }

    fn read(&mut self, _: &mut dyn InfallibleRead) -> PRes<u32> {
        Ok(0)
    fn read(&mut self, _: &mut dyn InfallibleRead) -> PRes<()> {
        Ok(())
    }

    fn recover(&self, _: &mut Transaction) -> PRes<RecoverStatus> {

@@ -523,8 +526,8 @@

Loading

        Ok(())
    }

    fn read(&mut self, _: &mut dyn InfallibleRead) -> PRes<u32> {
        Ok(0)
    fn read(&mut self, _: &mut dyn InfallibleRead) -> PRes<()> {
        Ok(())
    }

    fn recover(&self, _: &mut Transaction) -> PRes<RecoverStatus> {

@@ -541,8 +544,8 @@

Loading

        Ok(())
    }

    fn read(&mut self, _: &mut dyn InfallibleRead) -> PRes<u32> {
        Ok(0)
    fn read(&mut self, _: &mut dyn InfallibleRead) -> PRes<()> {
        Ok(())
    }

    fn recover(&self, _: &mut Transaction) -> PRes<RecoverStatus> {

@@ -556,20 +559,20 @@

Loading

    }

    fn write(&self, write: &mut dyn InfallibleWrite) -> PRes<()> {
        write.write_u8(self.strategy.value());
        write.write_varint_u8(self.strategy.value());
        let len = self.meta_id.len();
        write.write_u16(len as u16);
        write.write_varint_u16(len as u16);
        write.write_all(&self.meta_id);
        Ok(())
    }

    fn read(&mut self, read: &mut dyn InfallibleRead) -> PRes<u32> {
        self.strategy = TxStrategy::from_value(read.read_u8());
        let len = read.read_u16();
    fn read(&mut self, read: &mut dyn InfallibleRead) -> PRes<()> {
        self.strategy = TxStrategy::from_value(read.read_varint_u8());
        let len = read.read_varint_u16();
        let mut slice: Vec<u8> = vec![0; len as usize];
        read.read_exact(&mut slice[0..len as usize]);
        self.meta_id = slice;
        Ok(u32::from(1 + 2 + len))
        Ok(())
    }

    fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus> {

@@ -587,8 +590,8 @@

Loading

        Ok(())
    }

    fn read(&mut self, _: &mut dyn InfallibleRead) -> PRes<u32> {
        Ok(0)
    fn read(&mut self, _: &mut dyn InfallibleRead) -> PRes<()> {
        Ok(())
    }

    fn recover(&self, _: &mut Transaction) -> PRes<RecoverStatus> {

@@ -605,8 +608,8 @@

Loading

        Ok(())
    }

    fn read(&mut self, _: &mut dyn InfallibleRead) -> PRes<u32> {
        Ok(0)
    fn read(&mut self, _: &mut dyn InfallibleRead) -> PRes<()> {
        Ok(())
    }
    fn recover(&self, _: &mut Transaction) -> PRes<RecoverStatus> {
        Ok(RecoverStatus::Rollback)

@@ -619,21 +622,21 @@

Loading

    }

    fn write(&self, buffer: &mut dyn InfallibleWrite) -> PRes<()> {
        buffer.write_u32(self.segment_id);
        buffer.write_u64(self.first_page);
        buffer.write_u16(self.name.len() as u16);
        buffer.write_varint_u32(self.segment_id);
        buffer.write_varint_u64(self.first_page);
        buffer.write_varint_u16(self.name.len() as u16);
        buffer.write_all(self.name.as_bytes());
        Ok(())
    }

    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<u32> {
        self.segment_id = buffer.read_u32();
        self.first_page = buffer.read_u64();
        let string_size = buffer.read_u16();
    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<()> {
        self.segment_id = buffer.read_varint_u32();
        self.first_page = buffer.read_varint_u64();
        let string_size = buffer.read_varint_u16();
        let mut slice: Vec<u8> = vec![0; string_size as usize];
        buffer.read_exact(&mut slice[0..string_size as usize]);
        self.name = str::from_utf8(&slice[0..string_size as usize])?.into();
        Ok(u32::from(4 + string_size + 2 + 8))
        Ok(())
    }

    fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus> {

@@ -648,19 +651,19 @@

Loading

    }

    fn write(&self, buffer: &mut dyn InfallibleWrite) -> PRes<()> {
        buffer.write_u32(self.segment_id);
        buffer.write_u16(self.name.len() as u16);
        buffer.write_varint_u32(self.segment_id);
        buffer.write_varint_u16(self.name.len() as u16);
        buffer.write_all(self.name.as_bytes());
        Ok(())
    }

    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<u32> {
        self.segment_id = buffer.read_u32();
        let string_size = buffer.read_u16();
    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<()> {
        self.segment_id = buffer.read_varint_u32();
        let string_size = buffer.read_varint_u16();
        let mut slice: Vec<u8> = vec![0; string_size as usize];
        buffer.read_exact(&mut slice[0..string_size as usize]);
        self.name = str::from_utf8(&slice[0..string_size as usize])?.into();
        Ok(u32::from(4 + string_size + 2))
        Ok(())
    }

    fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus> {

@@ -679,9 +682,9 @@

Loading

        Ok(())
    }

    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<u32> {
    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<()> {
        self.page = buffer.read_u64();
        Ok((8) as u32)
        Ok(())
    }

    fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus> {

@@ -696,17 +699,17 @@

Loading

    }

    fn write(&self, buffer: &mut dyn InfallibleWrite) -> PRes<()> {
        buffer.write_u32(self.segment);
        buffer.write_u64(self.page);
        buffer.write_u64(self.previous);
        buffer.write_varint_u32(self.segment);
        buffer.write_varint_u64(self.page);
        buffer.write_varint_u64(self.previous);
        Ok(())
    }

    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<u32> {
        self.segment = buffer.read_u32();
        self.page = buffer.read_u64();
        self.previous = buffer.read_u64();
        Ok((4 + 8 + 8) as u32)
    fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<()> {
        self.segment = buffer.read_varint_u32();
        self.page = buffer.read_varint_u64();
        self.previous = buffer.read_varint_u64();
        Ok(())
    }

    fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus> {

Learn more Showing 1 files with coverage changes found.

Changes in src/io.rs

→

+19

Loading file...

94.14% 100.00% +<.01%

used varint format in journal record serialization

Unknown

e42e838

CI Passed

Files		•	•	•	Coverage
src	+35	+33	ø	+2	^0.01% 93.15%
tests	ø	ø	ø	ø	98.56%
Project Totals (29 files)	9,142	8,606	0	536	94.14%

122	122		fn is_free(&self) -> PRes<bool> {
123	123		Ok((self.buff[1] & 0b1000_0000) != 0)
124	124		}
	125	+	fn cursor_pos(&self) -> usize {
	126	+	if self.pos >= 2 {
	127	+	self.pos - 2
	128	+	} else {
	129	+	0
	130	+	}
	131	+	}
125	132		}
126	133
127	134		#[derive(Clone)]

139	146		fn clone_read(&self) -> ReadPage;
140	147		fn clone_write(&self) -> Page;
141	148		fn is_free(&self) -> PRes<bool>;
	149	+	fn cursor_pos(&self) -> usize;
142	150		}
143	151
144	152		fn free_flag_set(mut cur: u8, free: bool) -> u8 {

226	234		fn is_free(&self) -> PRes<bool> {
227	235		Ok(is_free(self.buff[1]))
228	236		}
	237	+	fn cursor_pos(&self) -> usize {
	238	+	if self.pos >= 2 {
	239	+	self.pos - 2
	240	+	} else {
	241	+	0
	242	+	}
	243	+	}
229	244		}
230	245
231	246		impl Page {

102	105		pub(crate) trait JournalEntry {
103	106		fn get_type(&self) -> u8;
104	107		fn write(&self, buffer: &mut dyn InfallibleWrite) -> PRes<()>;
105		-	fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<u32>;
	108	+	fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<()>;
106	109		fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus>;
107	110		}
108	111

114	117		pos: u32,
115	118		}
116	119
117		-	fn recover_entry<T>(entry: &mut dyn JournalEntry, page: &mut ReadPage, found: &mut T, id: &JournalId) -> PRes<u32>
	120	+	fn recover_entry<T>(entry: &mut dyn JournalEntry, page: &mut ReadPage, found: &mut T, id: &JournalId) -> PRes<()>
118	121		where
119	122		T: FnMut(&dyn JournalEntry, &JournalId),
120	123		{
121		-	let read_size = entry.read(page)?;
	124	+	entry.read(page)?;
122	125		found(entry, id);
123		-	Ok(read_size)
	126	+	Ok(())
124	127		}
125	128
126	129		impl Journal {

Compare `f126ad1 ... +1 ... e42e838`

No flags found

Show failed CI and contexual commits `c`

3 Commits

33	33
34	34		pub(crate) trait InfallibleReadVarInt: InfallibleRead {
35	35		#[inline]
36		-	fn read_u8_varint(&mut self) -> u8 {
	36	+	fn read_varint_u8(&mut self) -> u8 {
37	37		io::read_u8(InfallibleReadWrapper::new(self)).expect("infallible")
38	38		}
39	39
40	40		#[inline]
41		-	fn read_u16_varint(&mut self) -> u16 {
	41	+	fn read_varint_u16(&mut self) -> u16 {
42	42		io::read_u16(InfallibleReadWrapper::new(self)).expect("infallible")
43	43		}
44	44
45	45		#[inline]
46		-	fn read_u32_varint(&mut self) -> u32 {
	46	+	fn read_varint_u32(&mut self) -> u32 {
47	47		io::read_u32(InfallibleReadWrapper::new(self)).expect("infallible")
48	48		}
49	49
50	50		#[inline]
51		-	fn read_u64_varint(&mut self) -> u64 {
	51	+	fn read_varint_u64(&mut self) -> u64 {
52	52		io::read_u64(InfallibleReadWrapper::new(self)).expect("infallible")
53	53		}
54	54
55	55		#[inline]
56		-	fn read_u128_varint(&mut self) -> u128 {
	56	+	fn read_varint_u128(&mut self) -> u128 {
57	57		io::read_u128(InfallibleReadWrapper::new(self)).expect("infallible")
58	58		}
59	59
60	60		#[inline]
61		-	fn read_i8_varint(&mut self) -> i8 {
62		-	ZigZag::decode(self.read_u8_varint())
	61	+	fn read_varint_i8(&mut self) -> i8 {
	62	+	ZigZag::decode(self.read_varint_u8())
63	63		}
64	64
65	65		#[inline]
66		-	fn read_i16_varint(&mut self) -> i16 {
67		-	ZigZag::decode(self.read_u16_varint())
	66	+	fn read_varint_i16(&mut self) -> i16 {
	67	+	ZigZag::decode(self.read_varint_u16())
68	68		}
69	69
70	70		#[inline]
71		-	fn read_i32_varint(&mut self) -> i32 {
72		-	ZigZag::decode(self.read_u32_varint())
	71	+	fn read_varint_i32(&mut self) -> i32 {
	72	+	ZigZag::decode(self.read_varint_u32())
73	73		}
74	74
75	75		#[inline]
76		-	fn read_i64_varint(&mut self) -> i64 {
77		-	ZigZag::decode(self.read_u64_varint())
	76	+	fn read_varint_i64(&mut self) -> i64 {
	77	+	ZigZag::decode(self.read_varint_u64())
78	78		}
79	79
80	80		#[inline]
81		-	fn read_i128_varint(&mut self) -> i128 {
82		-	ZigZag::decode(self.read_u128_varint())
	81	+	fn read_varint_i128(&mut self) -> i128 {
	82	+	ZigZag::decode(self.read_varint_u128())
83	83		}
84	84		}
85	85		impl<R: InfallibleRead + ?Sized> InfallibleReadVarInt for R {}

8	8		discref::{Page, PageOps, ReadPage, PAGE_METADATA_SIZE},
9	9		error::PRes,
10	10		flush_checksum::{double_buffer_check, prepare_buffer_flush},
11		-	io::{read_u64, write_u64, InfallibleRead, InfallibleReadFormat, InfallibleWrite, InfallibleWriteFormat},
	11	+	io::{
	12	+	read_u64, write_u64, InfallibleRead, InfallibleReadFormat, InfallibleReadVarInt, InfallibleWrite,
	13	+	InfallibleWriteFormat, InfallibleWriteVarInt,
	14	+	},
12	15		persy::RecoverStatus,
13	16		};
14	17		use std::{

316	319		let mut cur_page = jr.first_page;
317	320		jr.last_page = jr.first_page;
318	321		journal_pages.push(cur_page);
319		-	let mut cur_cursor = JOURNAL_PAGE_CONTENT_OFFSET;
	322	+	let mut page = self.allocator.load_page(cur_page)?;
	323	+	page.seek(JOURNAL_PAGE_CONTENT_OFFSET)?;
320	324		loop {
321		-	let mut page = self.allocator.load_page(cur_page)?;
322		-	page.seek(cur_cursor)?;
323	325		let tp = page.read_u8();
324	326		if tp == 0 {
	327	+	let last_pos = page.cursor_pos() as u32;
325	328		page.seek(JOURNAL_PAGE_NEXT_OFFSET)?;
326	329		cur_page = page.read_u64();
327	330		if cur_page == 0 {
328		-	jr.last_pos = cur_cursor;
	331	+	jr.last_pos = last_pos - 1;
329	332		break;
330	333		}
331	334		journal_pages.push(cur_page);
332		-	cur_cursor = JOURNAL_PAGE_CONTENT_OFFSET;
	335	+	page = self.allocator.load_page(cur_page)?;
	336	+	page.seek(JOURNAL_PAGE_CONTENT_OFFSET)?;
333	337		jr.last_page = cur_page;
334	338		} else {
335	339		let page_id = page.read_u64();

337	341		let id = JournalId::new(page_id, pos);
338	342		let ref_page = &mut page;
339	343		let ref_found = &mut found;
340		-	let read_size = match tp {
	344	+	match tp {
341	345		//The Start entry has no valid id, should not be recovered
342	346		1 => Start::new().read(&mut page)?,
343	347		2 => recover_entry(&mut InsertRecord::default(), ref_page, ref_found, &id)?,

355	359		14 => recover_entry(&mut Cleanup::default(), ref_page, ref_found, &id)?,
356	360		_ => panic!(" wrong log entry {} ", tp),
357	361		};
358		-	cur_cursor = read_size + cur_cursor + 13;
359	362		}
360	363		}
361	364		jr.current = self.allocator.write_page(jr.last_page)?;

393	396		}
394	397
395	398		fn write(&self, buffer: &mut dyn InfallibleWrite) -> PRes<()> {
396		-	buffer.write_u32(self.segment);
397		-	buffer.write_u64(self.recref.page);
398		-	buffer.write_u32(self.recref.pos);
399		-	buffer.write_u16(self.version);
	399	+	buffer.write_varint_u32(self.segment);
	400	+	buffer.write_varint_u64(self.recref.page);
	401	+	buffer.write_varint_u32(self.recref.pos);
	402	+	buffer.write_varint_u16(self.version);
400	403		Ok(())
401	404		}
402	405
403		-	fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<u32> {
404		-	self.segment = buffer.read_u32();
405		-	self.recref.page = buffer.read_u64();
406		-	self.recref.pos = buffer.read_u32();
407		-	self.version = buffer.read_u16();
408		-	Ok(18)
	406	+	fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<()> {
	407	+	self.segment = buffer.read_varint_u32();
	408	+	self.recref.page = buffer.read_varint_u64();
	409	+	self.recref.pos = buffer.read_varint_u32();
	410	+	self.version = buffer.read_varint_u16();
	411	+	Ok(())
409	412		}
410	413
411	414		fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus> {

505	508		Ok(())
506	509		}
507	510
508		-	fn read(&mut self, _: &mut dyn InfallibleRead) -> PRes<u32> {
509		-	Ok(0)
	511	+	fn read(&mut self, _: &mut dyn InfallibleRead) -> PRes<()> {
	512	+	Ok(())
510	513		}
511	514
512	515		fn recover(&self, _: &mut Transaction) -> PRes<RecoverStatus> {

556	559		}
557	560
558	561		fn write(&self, write: &mut dyn InfallibleWrite) -> PRes<()> {
559		-	write.write_u8(self.strategy.value());
	562	+	write.write_varint_u8(self.strategy.value());
560	563		let len = self.meta_id.len();
561		-	write.write_u16(len as u16);
	564	+	write.write_varint_u16(len as u16);
562	565		write.write_all(&self.meta_id);
563	566		Ok(())
564	567		}
565	568
566		-	fn read(&mut self, read: &mut dyn InfallibleRead) -> PRes<u32> {
567		-	self.strategy = TxStrategy::from_value(read.read_u8());
568		-	let len = read.read_u16();
	569	+	fn read(&mut self, read: &mut dyn InfallibleRead) -> PRes<()> {
	570	+	self.strategy = TxStrategy::from_value(read.read_varint_u8());
	571	+	let len = read.read_varint_u16();
569	572		let mut slice: Vec<u8> = vec![0; len as usize];
570	573		read.read_exact(&mut slice[0..len as usize]);
571	574		self.meta_id = slice;
572		-	Ok(u32::from(1 + 2 + len))
	575	+	Ok(())
573	576		}
574	577
575	578		fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus> {

619	622		}
620	623
621	624		fn write(&self, buffer: &mut dyn InfallibleWrite) -> PRes<()> {
622		-	buffer.write_u32(self.segment_id);
623		-	buffer.write_u64(self.first_page);
624		-	buffer.write_u16(self.name.len() as u16);
	625	+	buffer.write_varint_u32(self.segment_id);
	626	+	buffer.write_varint_u64(self.first_page);
	627	+	buffer.write_varint_u16(self.name.len() as u16);
625	628		buffer.write_all(self.name.as_bytes());
626	629		Ok(())
627	630		}
628	631
629		-	fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<u32> {
630		-	self.segment_id = buffer.read_u32();
631		-	self.first_page = buffer.read_u64();
632		-	let string_size = buffer.read_u16();
	632	+	fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<()> {
	633	+	self.segment_id = buffer.read_varint_u32();
	634	+	self.first_page = buffer.read_varint_u64();
	635	+	let string_size = buffer.read_varint_u16();
633	636		let mut slice: Vec<u8> = vec![0; string_size as usize];
634	637		buffer.read_exact(&mut slice[0..string_size as usize]);
635	638		self.name = str::from_utf8(&slice[0..string_size as usize])?.into();
636		-	Ok(u32::from(4 + string_size + 2 + 8))
	639	+	Ok(())
637	640		}
638	641
639	642		fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus> {

696	699		}
697	700
698	701		fn write(&self, buffer: &mut dyn InfallibleWrite) -> PRes<()> {
699		-	buffer.write_u32(self.segment);
700		-	buffer.write_u64(self.page);
701		-	buffer.write_u64(self.previous);
	702	+	buffer.write_varint_u32(self.segment);
	703	+	buffer.write_varint_u64(self.page);
	704	+	buffer.write_varint_u64(self.previous);
702	705		Ok(())
703	706		}
704	707
705		-	fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<u32> {
706		-	self.segment = buffer.read_u32();
707		-	self.page = buffer.read_u64();
708		-	self.previous = buffer.read_u64();
709		-	Ok((4 + 8 + 8) as u32)
	708	+	fn read(&mut self, buffer: &mut dyn InfallibleRead) -> PRes<()> {
	709	+	self.segment = buffer.read_varint_u32();
	710	+	self.page = buffer.read_varint_u64();
	711	+	self.previous = buffer.read_varint_u64();
	712	+	Ok(())
710	713		}
711	714
712	715		fn recover(&self, tx: &mut Transaction) -> PRes<RecoverStatus> {

Navigation	Overlay
`t` Navigate files	`h` Toggle hits
`y` Change url to tip of branch	`m` Toggle misses
`b / v` Jump to prev/next hit line	`p` Toggle partial
`z / x` Jump to prev/next missed or partial line	`1..9` Toggle flags
`shift + o` Open current page in GitLab	`a` Toggle all on
`/ or ?` Show keyboard shortcuts dialog	`c` Toggle context lines or commits

Compare f126ad1 ... +1 ... e42e838

No flags found

Show failed CI and contexual commits c 3 Commits

Compare `f126ad1 ... +1 ... e42e838`

Show failed CI and contexual commits `c`

3 Commits