aljaz/turso
1
0
Fork 0
mirror of https://github.com/aljazceru/turso.git synced 2026-02-05 00:04:23 +01:00
Code Issues Packages Projects Releases Wiki Activity

underscoring completions and IOResult to avoid warning messages

Browse Source
This commit is contained in:
pedrocarlo
2025-07-30 15:47:49 -03:00
parent 6bfba2518e
commit 543cdb3e2c
6 changed files with 78 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
bindings/rust/src/lib.rs
View File

@@ -281,7 +281,7 @@ impl Connection {
.inner
.lock()
.map_err(|e| Error::MutexError(e.to_string()))?;
let res = conn.cacheflush()?;
let _res = conn.cacheflush()?;
Ok(())
}

119
core/storage/btree.rs
View File

@@ -137,7 +137,7 @@ macro_rules! return_if_locked_maybe_load {
return Ok(IOResult::IO);
}
if !$btree_page.get().is_loaded() {
let (page, c) = $pager.read_page($btree_page.get().get().id)?;
let (page, _c) = $pager.read_page($btree_page.get().get().id)?;
$btree_page.page.replace(page);
return Ok(IOResult::IO);
}
@@ -693,7 +693,7 @@ impl BTreeCursor {
let mv_cursor = mv_cursor.borrow();
return Ok(IOResult::Done(mv_cursor.is_empty()));
}
let (page, c) = self.pager.read_page(self.root_page)?;
let (page, _c) = self.pager.read_page(self.root_page)?;
*self.is_empty_table_state.borrow_mut() = EmptyTableState::ReadPage { page };
Ok(IOResult::IO)
}
@@ -729,7 +729,7 @@ impl BTreeCursor {
if let Some(rightmost_pointer) = rightmost_pointer {
let past_rightmost_pointer = cell_count as i32 + 1;
self.stack.set_cell_index(past_rightmost_pointer);
let (page, c) = self.read_page(rightmost_pointer as usize)?;
let (page, _c) = self.read_page(rightmost_pointer as usize)?;
self.stack.push_backwards(page);
continue;
}
@@ -793,7 +793,7 @@ impl BTreeCursor {
self.stack.retreat();
}
let (mem_page, _) = self.read_page(left_child_page as usize)?;
let (mem_page, _c) = self.read_page(left_child_page as usize)?;
self.stack.push_backwards(mem_page);
continue;
}
@@ -809,7 +809,7 @@ impl BTreeCursor {
payload_size: u64,
) -> Result<IOResult<()>> {
if self.read_overflow_state.borrow().is_none() {
let (page, c) = self.read_page(start_next_page as usize)?;
let (page, _c) = self.read_page(start_next_page as usize)?;
*self.read_overflow_state.borrow_mut() = Some(ReadPayloadOverflow {
payload: payload.to_vec(),
next_page: start_next_page,
@@ -841,7 +841,7 @@ impl BTreeCursor {
*remaining_to_read -= to_read;
if *remaining_to_read != 0 && next != 0 {
let (new_page, c) = self.pager.read_page(next as usize).map(|(page, c)| {
let (new_page, _c) = self.pager.read_page(next as usize).map(|(page, c)| {
(
Arc::new(BTreePageInner {
page: RefCell::new(page),
@@ -1048,7 +1048,7 @@ impl BTreeCursor {
is_write,
}) => {
if *pages_left_to_skip == 0 {
let (page, c) = self.read_page(*next_page as usize)?;
let (page, _c) = self.read_page(*next_page as usize)?;
return_if_locked_maybe_load!(self.pager, page);
self.state =
CursorState::ReadWritePayload(PayloadOverflowWithOffset::ProcessPage {
@@ -1063,7 +1063,7 @@ impl BTreeCursor {
continue;
}
let (page, c) = self.read_page(*next_page as usize)?;
let (page, _c) = self.read_page(*next_page as usize)?;
return_if_locked_maybe_load!(self.pager, page);
let page = page.get();
let contents = page.get_contents();
@@ -1158,7 +1158,7 @@ impl BTreeCursor {
// Load next page
*next_page = next;
*current_offset = 0; // Reset offset for new page
let (page, c) = self.read_page(next as usize)?;
let (page, _c) = self.read_page(next as usize)?;
*page_btree = page;
// Return IO to allow other operations
@@ -1270,7 +1270,7 @@ impl BTreeCursor {
(Some(right_most_pointer), false) => {
// do rightmost
self.stack.advance();
let (mem_page, c) = self.read_page(right_most_pointer as usize)?;
let (mem_page, _c) = self.read_page(right_most_pointer as usize)?;
self.stack.push(mem_page);
continue;
}
@@ -1308,7 +1308,7 @@ impl BTreeCursor {
}
let left_child_page = contents.cell_interior_read_left_child_page(cell_idx);
let (mem_page, _) = self.read_page(left_child_page as usize)?;
let (mem_page, _c) = self.read_page(left_child_page as usize)?;
self.stack.push(mem_page);
continue;
}
@@ -1348,14 +1348,14 @@ impl BTreeCursor {
fn move_to_rightmost(&mut self) -> Result<IOResult<bool>> {
match self.move_to_right_state {
MoveToRightState::Start => {
let c = self.move_to_root()?;
let _c = self.move_to_root()?;
self.move_to_right_state = MoveToRightState::ProcessPage;
return Ok(IOResult::IO);
}
MoveToRightState::ProcessPage => {
let mem_page = self.stack.top();
let page_idx = mem_page.get().get().id;
let (page, c) = self.read_page(page_idx)?;
let (page, _c) = self.read_page(page_idx)?;
return_if_locked_maybe_load!(self.pager, page);
let page = page.get();
let contents = page.get().contents.as_ref().unwrap();
@@ -1371,7 +1371,7 @@ impl BTreeCursor {
match contents.rightmost_pointer() {
Some(right_most_pointer) => {
self.stack.set_cell_index(contents.cell_count() as i32 + 1);
let (mem_page, c) = self.read_page(right_most_pointer as usize)?;
let (mem_page, _c) = self.read_page(right_most_pointer as usize)?;
self.stack.push(mem_page);
return Ok(IOResult::IO);
}
@@ -1439,7 +1439,7 @@ impl BTreeCursor {
let left_child_page =
contents.cell_interior_read_left_child_page(nearest_matching_cell);
self.stack.set_cell_index(nearest_matching_cell as i32);
let (mem_page, c) = self.read_page(left_child_page as usize)?;
let (mem_page, _c) = self.read_page(left_child_page as usize)?;
self.stack.push(mem_page);
self.seek_state = CursorSeekState::MovingBetweenPages {
eq_seen: Cell::new(eq_seen.get()),
@@ -1449,7 +1449,7 @@ impl BTreeCursor {
self.stack.set_cell_index(cell_count as i32 + 1);
match contents.rightmost_pointer() {
Some(right_most_pointer) => {
let (mem_page, c) = self.read_page(right_most_pointer as usize)?;
let (mem_page, _c) = self.read_page(right_most_pointer as usize)?;
self.stack.push(mem_page);
self.seek_state = CursorSeekState::MovingBetweenPages {
eq_seen: Cell::new(eq_seen.get()),
@@ -1580,7 +1580,7 @@ impl BTreeCursor {
self.stack.set_cell_index(contents.cell_count() as i32 + 1);
match contents.rightmost_pointer() {
Some(right_most_pointer) => {
let (mem_page, c) = self.read_page(right_most_pointer as usize)?;
let (mem_page, _c) = self.read_page(right_most_pointer as usize)?;
self.stack.push(mem_page);
self.seek_state = CursorSeekState::MovingBetweenPages {
eq_seen: Cell::new(eq_seen.get()),
@@ -1620,7 +1620,7 @@ impl BTreeCursor {
page.get().id
);
let (mem_page, c) = self.read_page(*left_child_page as usize)?;
let (mem_page, _c) = self.read_page(*left_child_page as usize)?;
self.stack.push(mem_page);
self.seek_state = CursorSeekState::MovingBetweenPages {
eq_seen: Cell::new(eq_seen.get()),
@@ -2122,7 +2122,7 @@ impl BTreeCursor {
self.seek_state = CursorSeekState::Start;
}
if matches!(self.seek_state, CursorSeekState::Start) {
let c = self.move_to_root()?;
let _c = self.move_to_root()?;
}
let ret = match key {
@@ -2440,7 +2440,7 @@ impl BTreeCursor {
}
if !self.stack.has_parent() {
let res = self.balance_root()?;
let _res = self.balance_root()?;
}
let write_info = self.state.mut_write_info().unwrap();
@@ -2608,7 +2608,7 @@ impl BTreeCursor {
let mut pgno: u32 = unsafe { right_pointer.cast::<u32>().read().swap_bytes() };
let current_sibling = sibling_pointer;
for i in (0..=current_sibling).rev() {
let (page, c) = self.read_page(pgno as usize)?;
let (page, _c) = self.read_page(pgno as usize)?;
{
// mark as dirty
let sibling_page = page.get();
@@ -4157,11 +4157,11 @@ impl BTreeCursor {
pub fn seek_end(&mut self) -> Result<IOResult<()>> {
assert!(self.mv_cursor.is_none()); // unsure about this -_-
let c = self.move_to_root()?;
let _c = self.move_to_root()?;
loop {
let mem_page = self.stack.top();
let page_id = mem_page.get().get().id;
let (page, c) = self.read_page(page_id)?;
let (page, _c) = self.read_page(page_id)?;
return_if_locked_maybe_load!(self.pager, page);
let page = page.get();
@@ -4175,7 +4175,7 @@ impl BTreeCursor {
match contents.rightmost_pointer() {
Some(right_most_pointer) => {
self.stack.set_cell_index(contents.cell_count() as i32 + 1); // invalid on interior
let (child, c) = self.read_page(right_most_pointer as usize)?;
let (child, _c) = self.read_page(right_most_pointer as usize)?;
self.stack.push(child);
}
None => unreachable!("interior page must have rightmost pointer"),
@@ -4216,7 +4216,7 @@ impl BTreeCursor {
self.invalidate_record();
self.has_record.replace(cursor_has_record);
} else {
let c = self.move_to_root()?;
let _c = self.move_to_root()?;
let cursor_has_record = return_if_io!(self.get_next_record());
self.invalidate_record();
@@ -4969,7 +4969,7 @@ impl BTreeCursor {
self.overflow_state = None;
return Err(LimboError::Corrupt("Invalid overflow page number".into()));
}
let (page, c) = self.read_page(next_page as usize)?;
let (page, _c) = self.read_page(next_page as usize)?;
return_if_locked_maybe_load!(self.pager, page);
let page = page.get();
@@ -5010,7 +5010,7 @@ impl BTreeCursor {
#[instrument(skip(self), level = Level::DEBUG)]
pub fn btree_destroy(&mut self) -> Result<IOResult<Option<usize>>> {
if let CursorState::None = &self.state {
let c = self.move_to_root()?;
let _c = self.move_to_root()?;
self.state = CursorState::Destroy(DestroyInfo {
state: DestroyState::Start,
});
@@ -5065,7 +5065,8 @@ impl BTreeCursor {
// Non-leaf page which has processed all children but not it's potential right child
(false, n) if n == contents.cell_count() as i32 => {
if let Some(rightmost) = contents.rightmost_pointer() {
let (rightmost_page, c) = self.read_page(rightmost as usize)?;
let (rightmost_page, _c) =
self.read_page(rightmost as usize)?;
self.stack.push(rightmost_page);
let destroy_info = self.state.mut_destroy_info().expect(
"unable to get a mut reference to destroy state in cursor",
@@ -5122,7 +5123,7 @@ impl BTreeCursor {
BTreeCell::IndexInteriorCell(cell) => cell.left_child_page,
_ => panic!("expected interior cell"),
};
let (child_page, c) = self.read_page(child_page_id as usize)?;
let (child_page, _c) = self.read_page(child_page_id as usize)?;
self.stack.push(child_page);
let destroy_info = self.state.mut_destroy_info().expect(
"unable to get a mut reference to destroy state in cursor",
@@ -5138,7 +5139,7 @@ impl BTreeCursor {
IOResult::Done(_) => match cell {
// For an index interior cell, clear the left child page now that overflow pages have been cleared
BTreeCell::IndexInteriorCell(index_int_cell) => {
let (child_page, c) =
let (child_page, _c) =
self.read_page(index_int_cell.left_child_page as usize)?;
self.stack.push(child_page);
let destroy_info = self.state.mut_destroy_info().expect(
@@ -5261,7 +5262,7 @@ impl BTreeCursor {
let new_payload = &mut *new_payload;
// if it all fits in local space and old_local_size is enough, do an in-place overwrite
if new_payload.len() == *old_local_size {
let res =
let _res =
self.overwrite_content(page_ref.clone(), *old_offset, new_payload)?;
return Ok(IOResult::Done(()));
}
@@ -5319,7 +5320,7 @@ impl BTreeCursor {
#[instrument(skip(self), level = Level::DEBUG)]
pub fn count(&mut self) -> Result<IOResult<usize>> {
if self.count == 0 {
let c = self.move_to_root()?;
let _c = self.move_to_root()?;
}
if let Some(_mv_cursor) = &self.mv_cursor {
@@ -5352,7 +5353,7 @@ impl BTreeCursor {
loop {
if !self.stack.has_parent() {
// All pages of the b-tree have been visited. Return successfully
let c = self.move_to_root()?;
let _c = self.move_to_root()?;
return Ok(IOResult::Done(self.count));
}
@@ -5383,7 +5384,7 @@ impl BTreeCursor {
// should be safe as contents is not a leaf page
let right_most_pointer = contents.rightmost_pointer().unwrap();
self.stack.advance();
let (mem_page, c) = self.read_page(right_most_pointer as usize)?;
let (mem_page, _c) = self.read_page(right_most_pointer as usize)?;
self.stack.push(mem_page);
} else {
// Move to child left page
@@ -5397,7 +5398,7 @@ impl BTreeCursor {
left_child_page, ..
}) => {
self.stack.advance();
let (mem_page, c) = self.read_page(left_child_page as usize)?;
let (mem_page, _c) = self.read_page(left_child_page as usize)?;
self.stack.push(mem_page);
}
_ => unreachable!(),
@@ -5577,7 +5578,7 @@ pub fn integrity_check(
else {
return Ok(IOResult::Done(()));
};
let (page, c) = btree_read_page(pager, page_idx)?;
let (page, _c) = btree_read_page(pager, page_idx)?;
return_if_locked_maybe_load!(pager, page);
state.page_stack.pop();
@@ -7189,7 +7190,7 @@ mod tests {
fn validate_btree(pager: Rc<Pager>, page_idx: usize) -> (usize, bool) {
let num_columns = 5;
let cursor = BTreeCursor::new_table(None, pager.clone(), page_idx, num_columns);
let (page, c) = cursor.read_page(page_idx).unwrap();
let (page, _c) = cursor.read_page(page_idx).unwrap();
while page.get().is_locked() {
pager.io.run_once().unwrap();
}
@@ -7209,7 +7210,7 @@ mod tests {
BTreeCell::TableInteriorCell(TableInteriorCell {
left_child_page, ..
}) => {
let (child_page, c) = cursor.read_page(left_child_page as usize).unwrap();
let (child_page, _c) = cursor.read_page(left_child_page as usize).unwrap();
while child_page.get().is_locked() {
pager.io.run_once().unwrap();
}
@@ -7266,7 +7267,7 @@ mod tests {
}
let first_page_type = child_pages.first().map(|p| {
if !p.get().is_loaded() {
let (new_page, c) = pager.read_page(p.get().get().id).unwrap();
let (new_page, _c) = pager.read_page(p.get().get().id).unwrap();
p.page.replace(new_page);
}
while p.get().is_locked() {
@@ -7277,7 +7278,7 @@ mod tests {
if let Some(child_type) = first_page_type {
for page in child_pages.iter().skip(1) {
if !page.get().is_loaded() {
let (new_page, c) = pager.read_page(page.get().get().id).unwrap();
let (new_page, _c) = pager.read_page(page.get().get().id).unwrap();
page.page.replace(new_page);
}
while page.get().is_locked() {
@@ -7300,7 +7301,7 @@ mod tests {
let num_columns = 5;
let cursor = BTreeCursor::new_table(None, pager.clone(), page_idx, num_columns);
let (page, c) = cursor.read_page(page_idx).unwrap();
let (page, _c) = cursor.read_page(page_idx).unwrap();
while page.get().is_locked() {
pager.io.run_once().unwrap();
}
@@ -7668,10 +7669,10 @@ mod tests {
}
pager.begin_read_tx().unwrap();
// FIXME: add sorted vector instead, should be okay for small amounts of keys for now :P, too lazy to fix right now
let c = cursor.move_to_root().unwrap();
let _c = cursor.move_to_root().unwrap();
let mut valid = true;
if do_validate {
let c = cursor.move_to_root().unwrap();
let _c = cursor.move_to_root().unwrap();
for key in keys.iter() {
tracing::trace!("seeking key: {}", key);
run_until_done(|| cursor.next(), pager.deref()).unwrap();
@@ -7704,7 +7705,7 @@ mod tests {
if matches!(validate_btree(pager.clone(), root_page), (_, false)) {
panic!("invalid btree");
}
let c = cursor.move_to_root().unwrap();
let _c = cursor.move_to_root().unwrap();
for key in keys.iter() {
tracing::trace!("seeking key: {}", key);
run_until_done(|| cursor.next(), pager.deref()).unwrap();
@@ -7772,7 +7773,7 @@ mod tests {
tracing::info!("seed: {seed}");
for i in 0..inserts {
pager.begin_read_tx().unwrap();
let res = pager.begin_write_tx().unwrap();
let _res = pager.begin_write_tx().unwrap();
let key = {
let result;
loop {
@@ -7815,7 +7816,7 @@ mod tests {
pager.deref(),
)
.unwrap();
let c = cursor.move_to_root().unwrap();
let _c = cursor.move_to_root().unwrap();
loop {
match pager.end_tx(false, false, &conn, false).unwrap() {
IOResult::Done(_) => break,
@@ -7828,7 +7829,7 @@ mod tests {
// Check that all keys can be found by seeking
pager.begin_read_tx().unwrap();
let c = cursor.move_to_root().unwrap();
let _c = cursor.move_to_root().unwrap();
for (i, key) in keys.iter().enumerate() {
tracing::info!("seeking key {}/{}: {:?}", i + 1, keys.len(), key);
let exists = run_until_done(
@@ -7852,7 +7853,7 @@ mod tests {
assert!(found, "key {key:?} is not found");
}
// Check that key count is right
let c = cursor.move_to_root().unwrap();
let _c = cursor.move_to_root().unwrap();
let mut count = 0;
while run_until_done(|| cursor.next(), pager.deref()).unwrap() {
count += 1;
@@ -7865,7 +7866,7 @@ mod tests {
keys.len()
);
// Check that all keys can be found in-order, by iterating the btree
let c = cursor.move_to_root().unwrap();
let _c = cursor.move_to_root().unwrap();
let mut prev = None;
for (i, key) in keys.iter().enumerate() {
tracing::info!("iterating key {}/{}: {:?}", i + 1, keys.len(), key);
@@ -7942,7 +7943,7 @@ mod tests {
for i in 0..operations {
let print_progress = i % 100 == 0;
pager.begin_read_tx().unwrap();
let res = pager.begin_write_tx().unwrap();
let _res = pager.begin_write_tx().unwrap();
// Decide whether to insert or delete (80% chance of insert)
let is_insert = rng.next_u64() % 100 < (insert_chance * 100.0) as u64;
@@ -8033,7 +8034,7 @@ mod tests {
}
}
let c = cursor.move_to_root().unwrap();
let _c = cursor.move_to_root().unwrap();
loop {
match pager.end_tx(false, false, &conn, false).unwrap() {
IOResult::Done(_) => break,
@@ -8061,7 +8062,7 @@ mod tests {
) {
// Check that all expected keys can be found by seeking
pager.begin_read_tx().unwrap();
let c = cursor.move_to_root().unwrap();
let _c = cursor.move_to_root().unwrap();
for (i, key) in expected_keys.iter().enumerate() {
tracing::info!(
"validating key {}/{}, seed: {seed}",
@@ -8087,7 +8088,7 @@ mod tests {
}
// Check key count
let c = cursor.move_to_root().unwrap();
let _c = cursor.move_to_root().unwrap();
run_until_done(|| cursor.rewind(), pager.deref()).unwrap();
if !cursor.has_record.get() {
panic!("no keys in tree");
@@ -8109,7 +8110,7 @@ mod tests {
);
// Check that all keys can be found in-order, by iterating the btree
let c = cursor.move_to_root().unwrap();
let _c = cursor.move_to_root().unwrap();
for (i, key) in expected_keys.iter().enumerate() {
run_until_done(|| cursor.next(), pager.deref()).unwrap();
tracing::info!(
@@ -8323,7 +8324,7 @@ mod tests {
let _ = run_until_done(|| pager.allocate_page1(), &pager);
for _ in 0..(database_size - 1) {
let res = pager.allocate_page().unwrap();
let _res = pager.allocate_page().unwrap();
}
pager
@@ -8363,12 +8364,12 @@ mod tests {
)));
let c = Completion::new_write(|_| {});
#[allow(clippy::arc_with_non_send_sync)]
let c = pager
let _c = pager
.db_file
.write_page(current_page as usize, buf.clone(), c)?;
pager.io.run_once()?;
let (page, c) = cursor.read_page(current_page as usize)?;
let (page, _c) = cursor.read_page(current_page as usize)?;
while page.get().is_locked() {
cursor.pager.io.run_once()?;
}
@@ -8431,7 +8432,7 @@ mod tests {
let trunk_page_id = freelist_trunk_page;
if trunk_page_id > 0 {
// Verify trunk page structure
let (trunk_page, c) = cursor.read_page(trunk_page_id as usize)?;
let (trunk_page, _c) = cursor.read_page(trunk_page_id as usize)?;
if let Some(contents) = trunk_page.get().get().contents.as_ref() {
// Read number of leaf pages in trunk
let n_leaf = contents.read_u32(4);
@@ -9412,7 +9413,7 @@ mod tests {
);
}
let mut cursor = BTreeCursor::new_table(None, pager.clone(), root_page, num_columns);
let c = cursor.move_to_root().unwrap();
let _c = cursor.move_to_root().unwrap();
for i in 0..iterations {
let has_next = run_until_done(|| cursor.next(), pager.deref()).unwrap();
if !has_next {

24
core/storage/pager.rs
View File

@@ -491,7 +491,7 @@ impl Pager {
ptrmap_pg_no
);
let (ptrmap_page, c) = self.read_page(ptrmap_pg_no as usize)?;
let (ptrmap_page, _c) = self.read_page(ptrmap_pg_no as usize)?;
if ptrmap_page.is_locked() {
return Ok(IOResult::IO);
}
@@ -579,7 +579,7 @@ impl Pager {
offset_in_ptrmap_page
);
let (ptrmap_page, c) = self.read_page(ptrmap_pg_no as usize)?;
let (ptrmap_page, _c) = self.read_page(ptrmap_pg_no as usize)?;
if ptrmap_page.is_locked() {
return Ok(IOResult::IO);
}
@@ -973,7 +973,7 @@ impl Pager {
page
};
let c = self.wal.borrow_mut().append_frame(
let _c = self.wal.borrow_mut().append_frame(
page.clone(),
0,
self.flush_info.borrow().in_flight_writes.clone(),
@@ -1088,7 +1088,7 @@ impl Pager {
0
}
};
let c = self.wal.borrow_mut().append_frame(
let _c = self.wal.borrow_mut().append_frame(
page.clone(),
db_size,
self.commit_info.borrow().in_flight_writes.clone(),
@@ -1155,7 +1155,8 @@ impl Pager {
self.commit_info.borrow_mut().state = CommitState::SyncDbFile;
}
CommitState::SyncDbFile => {
let c = sqlite3_ondisk::begin_sync(self.db_file.clone(), self.syncing.clone())?;
let _c =
sqlite3_ondisk::begin_sync(self.db_file.clone(), self.syncing.clone())?;
self.commit_info.borrow_mut().state = CommitState::WaitSyncDbFile;
}
CommitState::WaitSyncDbFile => {
@@ -1236,7 +1237,8 @@ impl Pager {
};
}
CheckpointState::SyncDbFile => {
let c = sqlite3_ondisk::begin_sync(self.db_file.clone(), self.syncing.clone())?;
let _c =
sqlite3_ondisk::begin_sync(self.db_file.clone(), self.syncing.clone())?;
self.checkpoint_state
.replace(CheckpointState::WaitSyncDbFile);
}
@@ -1372,7 +1374,7 @@ impl Pager {
)));
}
let (page, c) = match page.clone() {
let (page, _c) = match page.clone() {
Some(page) => {
assert_eq!(
page.get().id,
@@ -1409,7 +1411,7 @@ impl Pager {
let trunk_page_id = header.freelist_trunk_page.get();
if trunk_page.is_none() {
// Add as leaf to current trunk
let (page, c) = self.read_page(trunk_page_id as usize)?;
let (page, _c) = self.read_page(trunk_page_id as usize)?;
trunk_page.replace(page);
}
let trunk_page = trunk_page.as_ref().unwrap();
@@ -1506,7 +1508,7 @@ impl Pager {
(default_header.page_size.get() - default_header.reserved_space as u32) as u16,
);
let write_counter = Rc::new(RefCell::new(0));
let c = begin_write_btree_page(self, &page1.get(), write_counter.clone())?;
let _c = begin_write_btree_page(self, &page1.get(), write_counter.clone())?;
self.allocate_page1_state
.replace(AllocatePage1State::Writing {
@@ -1609,7 +1611,7 @@ impl Pager {
};
continue;
}
let (trunk_page, c) = self.read_page(first_freelist_trunk_page_id as usize)?;
let (trunk_page, _c) = self.read_page(first_freelist_trunk_page_id as usize)?;
*state = AllocatePageState::SearchAvailableFreeListLeaf {
trunk_page,
current_db_size: new_db_size,
@@ -1695,7 +1697,7 @@ impl Pager {
let page_contents = trunk_page.get().contents.as_ref().unwrap();
let next_leaf_page_id =
page_contents.read_u32(FREELIST_TRUNK_OFFSET_FIRST_LEAF);
let (leaf_page, c) = self.read_page(next_leaf_page_id as usize)?;
let (leaf_page, _c) = self.read_page(next_leaf_page_id as usize)?;
if leaf_page.is_locked() {
return Ok(IOResult::IO);
}

2
core/storage/sqlite3_ondisk.rs
View File

@@ -1695,7 +1695,7 @@ pub fn read_entire_wal_dumb(file: &Arc<dyn File>) -> Result<Arc<UnsafeCell<WalFi
wfs_data.loaded.store(true, Ordering::SeqCst);
});
let c = Completion::new_read(buf_for_pread, complete);
let c = file.pread(0, c)?;
let _c = file.pread(0, c)?;
Ok(wal_file_shared_ret)
}

4
core/vdbe/sorter.rs
View File

@@ -402,7 +402,7 @@ impl SortedChunk {
read_buffer_ref,
read_complete,
)));
let c = self.file.pread(self.total_bytes_read.get(), c)?;
let _c = self.file.pread(self.total_bytes_read.get(), c)?;
Ok(())
}
@@ -448,7 +448,7 @@ impl SortedChunk {
});
let c = Completion::new(CompletionType::Write(WriteCompletion::new(write_complete)));
let c = self.file.pwrite(0, buffer_ref, c)?;
let _c = self.file.pwrite(0, buffer_ref, c)?;
Ok(())
}
}

2
simulator/runner/file.rs
View File

@@ -121,7 +121,7 @@ impl SimulatorFile {
if queued_io[i].time <= now {
let io = queued_io.remove(i);
// your code here
let c = (io.op)(self)?;
let _c = (io.op)(self)?;
} else {
i += 1;
}