diff --git a/core/storage/btree.rs b/core/storage/btree.rs index ab263e406..962e5d51a 100644 --- a/core/storage/btree.rs +++ b/core/storage/btree.rs @@ -7324,7 +7324,7 @@ mod tests { fn add_record( id: usize, pos: usize, - page: &mut PageContent, + page: PageRef, record: ImmutableRecord, conn: &Arc, ) -> Vec { @@ -7333,7 +7333,7 @@ mod tests { run_until_done( || { fill_cell_payload( - page, + page.clone(), Some(id as i64), &mut payload, pos, @@ -7346,7 +7346,7 @@ mod tests { &conn.pager.borrow().clone(), ) .unwrap(); - insert_into_cell(page, &payload, pos, 4096).unwrap(); + insert_into_cell(page.get_contents(), &payload, pos, 4096).unwrap(); payload } @@ -7356,17 +7356,17 @@ mod tests { let conn = db.connect().unwrap(); let page = get_page(2); let page = page.get(); - let page = page.get_contents(); let header_size = 8; let regs = &[Register::Value(Value::Integer(1))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let payload = add_record(1, 0, page, record, &conn); - assert_eq!(page.cell_count(), 1); - let free = compute_free_space(page, 4096); + let payload = add_record(1, 0, page.clone(), record, &conn); + let page_contents = page.get_contents(); + assert_eq!(page_contents.cell_count(), 1); + let free = compute_free_space(page_contents, 4096); assert_eq!(free, 4096 - payload.len() - 2 - header_size); let cell_idx = 0; - ensure_cell(page, cell_idx, &payload); + ensure_cell(page_contents, cell_idx, &payload); } struct Cell { @@ -7381,7 +7381,7 @@ mod tests { let page = get_page(2); let page = page.get(); - let page = page.get_contents(); + let page_contents = page.get_contents(); let header_size = 8; let mut total_size = 0; @@ -7390,22 +7390,22 @@ mod tests { for i in 0..3 { let regs = &[Register::Value(Value::Integer(i as i64))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let payload = add_record(i, i, page, record, &conn); - assert_eq!(page.cell_count(), i + 1); - let free = compute_free_space(page, usable_space); + let payload = add_record(i, i, page.clone(), record, &conn); + assert_eq!(page_contents.cell_count(), i + 1); + let free = compute_free_space(page_contents, usable_space); total_size += payload.len() + 2; assert_eq!(free, 4096 - total_size - header_size); cells.push(Cell { pos: i, payload }); } for (i, cell) in cells.iter().enumerate() { - ensure_cell(page, i, &cell.payload); + ensure_cell(page_contents, i, &cell.payload); } cells.remove(1); - drop_cell(page, 1, usable_space).unwrap(); + drop_cell(page_contents, 1, usable_space).unwrap(); for (i, cell) in cells.iter().enumerate() { - ensure_cell(page, i, &cell.payload); + ensure_cell(page_contents, i, &cell.payload); } } @@ -8360,7 +8360,7 @@ mod tests { let page = get_page(2); let page = page.get(); - let page = page.get_contents(); + let page_contents = page.get_contents(); let header_size = 8; let mut total_size = 0; @@ -8370,9 +8370,9 @@ mod tests { for i in 0..total_cells { let regs = &[Register::Value(Value::Integer(i as i64))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let payload = add_record(i, i, page, record, &conn); - assert_eq!(page.cell_count(), i + 1); - let free = compute_free_space(page, usable_space); + let payload = add_record(i, i, page.clone(), record, &conn); + assert_eq!(page_contents.cell_count(), i + 1); + let free = compute_free_space(page_contents, usable_space); total_size += payload.len() + 2; assert_eq!(free, 4096 - total_size - header_size); cells.push(Cell { pos: i, payload }); @@ -8382,7 +8382,7 @@ mod tests { let mut new_cells = Vec::new(); for cell in cells { if cell.pos % 2 == 1 { - drop_cell(page, cell.pos - removed, usable_space).unwrap(); + drop_cell(page_contents, cell.pos - removed, usable_space).unwrap(); removed += 1; } else { new_cells.push(cell); @@ -8390,11 +8390,11 @@ mod tests { } let cells = new_cells; for (i, cell) in cells.iter().enumerate() { - ensure_cell(page, i, &cell.payload); + ensure_cell(page_contents, i, &cell.payload); } for (i, cell) in cells.iter().enumerate() { - ensure_cell(page, i, &cell.payload); + ensure_cell(page_contents, i, &cell.payload); } } @@ -8812,7 +8812,7 @@ mod tests { let page = get_page(2); let page = page.get(); - let page = page.get_contents(); + let page_contents = page.get_contents(); let header_size = 8; let mut total_size = 0; @@ -8821,28 +8821,28 @@ mod tests { for i in 0..3 { let regs = &[Register::Value(Value::Integer(i as i64))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let payload = add_record(i, i, page, record, &conn); - assert_eq!(page.cell_count(), i + 1); - let free = compute_free_space(page, usable_space); + let payload = add_record(i, i, page.clone(), record, &conn); + assert_eq!(page_contents.cell_count(), i + 1); + let free = compute_free_space(page_contents, usable_space); total_size += payload.len() + 2; assert_eq!(free, 4096 - total_size - header_size); cells.push(Cell { pos: i, payload }); } for (i, cell) in cells.iter().enumerate() { - ensure_cell(page, i, &cell.payload); + ensure_cell(page_contents, i, &cell.payload); } cells.remove(1); - drop_cell(page, 1, usable_space).unwrap(); + drop_cell(page_contents, 1, usable_space).unwrap(); for (i, cell) in cells.iter().enumerate() { - ensure_cell(page, i, &cell.payload); + ensure_cell(page_contents, i, &cell.payload); } - defragment_page(page, usable_space, 4).unwrap(); + defragment_page(page_contents, usable_space, 4).unwrap(); for (i, cell) in cells.iter().enumerate() { - ensure_cell(page, i, &cell.payload); + ensure_cell(page_contents, i, &cell.payload); } } @@ -8853,7 +8853,7 @@ mod tests { let page = get_page(2); let page = page.get(); - let page = page.get_contents(); + let page_contents = page.get_contents(); let header_size = 8; let mut total_size = 0; @@ -8863,9 +8863,9 @@ mod tests { for i in 0..total_cells { let regs = &[Register::Value(Value::Integer(i as i64))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let payload = add_record(i, i, page, record, &conn); - assert_eq!(page.cell_count(), i + 1); - let free = compute_free_space(page, usable_space); + let payload = add_record(i, i, page.clone(), record, &conn); + assert_eq!(page_contents.cell_count(), i + 1); + let free = compute_free_space(page_contents, usable_space); total_size += payload.len() + 2; assert_eq!(free, 4096 - total_size - header_size); cells.push(Cell { pos: i, payload }); @@ -8875,7 +8875,7 @@ mod tests { let mut new_cells = Vec::new(); for cell in cells { if cell.pos % 2 == 1 { - drop_cell(page, cell.pos - removed, usable_space).unwrap(); + drop_cell(page_contents, cell.pos - removed, usable_space).unwrap(); removed += 1; } else { new_cells.push(cell); @@ -8883,13 +8883,13 @@ mod tests { } let cells = new_cells; for (i, cell) in cells.iter().enumerate() { - ensure_cell(page, i, &cell.payload); + ensure_cell(page_contents, i, &cell.payload); } - defragment_page(page, usable_space, 4).unwrap(); + defragment_page(page_contents, usable_space, 4).unwrap(); for (i, cell) in cells.iter().enumerate() { - ensure_cell(page, i, &cell.payload); + ensure_cell(page_contents, i, &cell.payload); } } @@ -8900,7 +8900,7 @@ mod tests { let page = get_page(2); let page = page.get(); - let page = page.get_contents(); + let page_contents = page.get_contents(); let header_size = 8; let mut total_size = 0; @@ -8915,8 +8915,8 @@ mod tests { match rng.next_u64() % 4 { 0 => { // allow appends with extra place to insert - let cell_idx = rng.next_u64() as usize % (page.cell_count() + 1); - let free = compute_free_space(page, usable_space); + let cell_idx = rng.next_u64() as usize % (page_contents.cell_count() + 1); + let free = compute_free_space(page_contents, usable_space); let regs = &[Register::Value(Value::Integer(i as i64))]; let record = ImmutableRecord::from_registers(regs, regs.len()); let mut payload: Vec = Vec::new(); @@ -8924,7 +8924,7 @@ mod tests { run_until_done( || { fill_cell_payload( - page, + page.clone(), Some(i as i64), &mut payload, cell_idx, @@ -8941,34 +8941,34 @@ mod tests { // do not try to insert overflow pages because they require balancing continue; } - insert_into_cell(page, &payload, cell_idx, 4096).unwrap(); - assert!(page.overflow_cells.is_empty()); + insert_into_cell(page_contents, &payload, cell_idx, 4096).unwrap(); + assert!(page_contents.overflow_cells.is_empty()); total_size += payload.len() + 2; cells.insert(cell_idx, Cell { pos: i, payload }); } 1 => { - if page.cell_count() == 0 { + if page_contents.cell_count() == 0 { continue; } - let cell_idx = rng.next_u64() as usize % page.cell_count(); - let (_, len) = page.cell_get_raw_region(cell_idx, usable_space); - drop_cell(page, cell_idx, usable_space).unwrap(); + let cell_idx = rng.next_u64() as usize % page_contents.cell_count(); + let (_, len) = page_contents.cell_get_raw_region(cell_idx, usable_space); + drop_cell(page_contents, cell_idx, usable_space).unwrap(); total_size -= len + 2; cells.remove(cell_idx); } 2 => { - defragment_page(page, usable_space, 4).unwrap(); + defragment_page(page_contents, usable_space, 4).unwrap(); } 3 => { // check cells for (i, cell) in cells.iter().enumerate() { - ensure_cell(page, i, &cell.payload); + ensure_cell(page_contents, i, &cell.payload); } - assert_eq!(page.cell_count(), cells.len()); + assert_eq!(page_contents.cell_count(), cells.len()); } _ => unreachable!(), } - let free = compute_free_space(page, usable_space); + let free = compute_free_space(page_contents, usable_space); assert_eq!(free, 4096 - total_size - header_size); } } @@ -8982,7 +8982,7 @@ mod tests { let page = get_page(2); let page = page.get(); - let page = page.get_contents(); + let page_contents = page.get_contents(); let header_size = 8; let mut total_size = 0; @@ -8997,8 +8997,8 @@ mod tests { match rng.next_u64() % 3 { 0 => { // allow appends with extra place to insert - let cell_idx = rng.next_u64() as usize % (page.cell_count() + 1); - let free = compute_free_space(page, usable_space); + let cell_idx = rng.next_u64() as usize % (page_contents.cell_count() + 1); + let free = compute_free_space(page_contents, usable_space); let regs = &[Register::Value(Value::Integer(i))]; let record = ImmutableRecord::from_registers(regs, regs.len()); let mut payload: Vec = Vec::new(); @@ -9006,7 +9006,7 @@ mod tests { run_until_done( || { fill_cell_payload( - page, + page.clone(), Some(i), &mut payload, cell_idx, @@ -9023,8 +9023,8 @@ mod tests { // do not try to insert overflow pages because they require balancing continue; } - insert_into_cell(page, &payload, cell_idx, 4096).unwrap(); - assert!(page.overflow_cells.is_empty()); + insert_into_cell(page_contents, &payload, cell_idx, 4096).unwrap(); + assert!(page_contents.overflow_cells.is_empty()); total_size += payload.len() + 2; cells.push(Cell { pos: i as usize, @@ -9032,21 +9032,21 @@ mod tests { }); } 1 => { - if page.cell_count() == 0 { + if page_contents.cell_count() == 0 { continue; } - let cell_idx = rng.next_u64() as usize % page.cell_count(); - let (_, len) = page.cell_get_raw_region(cell_idx, usable_space); - drop_cell(page, cell_idx, usable_space).unwrap(); + let cell_idx = rng.next_u64() as usize % page_contents.cell_count(); + let (_, len) = page_contents.cell_get_raw_region(cell_idx, usable_space); + drop_cell(page_contents, cell_idx, usable_space).unwrap(); total_size -= len + 2; cells.remove(cell_idx); } 2 => { - defragment_page(page, usable_space, 4).unwrap(); + defragment_page(page_contents, usable_space, 4).unwrap(); } _ => unreachable!(), } - let free = compute_free_space(page, usable_space); + let free = compute_free_space(page_contents, usable_space); assert_eq!(free, 4096 - total_size - header_size); } } @@ -9158,14 +9158,14 @@ mod tests { let conn = db.connect().unwrap(); let page = get_page(2); let page = page.get(); - let page = page.get_contents(); + let page_contents = page.get_contents(); let header_size = 8; let usable_space = 4096; let regs = &[Register::Value(Value::Integer(0))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let payload = add_record(0, 0, page, record, &conn); - let free = compute_free_space(page, usable_space); + let payload = add_record(0, 0, page.clone(), record, &conn); + let free = compute_free_space(page_contents, usable_space); assert_eq!(free, 4096 - payload.len() - 2 - header_size); } @@ -9176,18 +9176,18 @@ mod tests { let page = get_page(2); let page = page.get(); - let page = page.get_contents(); + let page_contents = page.get_contents(); let usable_space = 4096; let regs = &[Register::Value(Value::Integer(0))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let payload = add_record(0, 0, page, record, &conn); + let payload = add_record(0, 0, page.clone(), record, &conn); - assert_eq!(page.cell_count(), 1); - defragment_page(page, usable_space, 4).unwrap(); - assert_eq!(page.cell_count(), 1); - let (start, len) = page.cell_get_raw_region(0, usable_space); - let buf = page.as_ptr(); + assert_eq!(page_contents.cell_count(), 1); + defragment_page(page_contents, usable_space, 4).unwrap(); + assert_eq!(page_contents.cell_count(), 1); + let (start, len) = page_contents.cell_get_raw_region(0, usable_space); + let buf = page_contents.as_ptr(); assert_eq!(&payload, &buf[start..start + len]); } @@ -9198,7 +9198,7 @@ mod tests { let page = get_page(2); let page = page.get(); - let page = page.get_contents(); + let page_contents = page.get_contents(); let usable_space = 4096; let regs = &[ @@ -9206,19 +9206,19 @@ mod tests { Register::Value(Value::Text(Text::new("aaaaaaaa"))), ]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let _ = add_record(0, 0, page, record, &conn); + let _ = add_record(0, 0, page.clone(), record, &conn); - assert_eq!(page.cell_count(), 1); - drop_cell(page, 0, usable_space).unwrap(); - assert_eq!(page.cell_count(), 0); + assert_eq!(page_contents.cell_count(), 1); + drop_cell(page_contents, 0, usable_space).unwrap(); + assert_eq!(page_contents.cell_count(), 0); let regs = &[Register::Value(Value::Integer(0))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let payload = add_record(0, 0, page, record, &conn); - assert_eq!(page.cell_count(), 1); + let payload = add_record(0, 0, page.clone(), record, &conn); + assert_eq!(page_contents.cell_count(), 1); - let (start, len) = page.cell_get_raw_region(0, usable_space); - let buf = page.as_ptr(); + let (start, len) = page_contents.cell_get_raw_region(0, usable_space); + let buf = page_contents.as_ptr(); assert_eq!(&payload, &buf[start..start + len]); } @@ -9229,7 +9229,7 @@ mod tests { let page = get_page(2); let page = page.get(); - let page = page.get_contents(); + let page_contents = page.get_contents(); let usable_space = 4096; let regs = &[ @@ -9237,20 +9237,20 @@ mod tests { Register::Value(Value::Text(Text::new("aaaaaaaa"))), ]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let _ = add_record(0, 0, page, record, &conn); + let _ = add_record(0, 0, page.clone(), record, &conn); for _ in 0..100 { - assert_eq!(page.cell_count(), 1); - drop_cell(page, 0, usable_space).unwrap(); - assert_eq!(page.cell_count(), 0); + assert_eq!(page_contents.cell_count(), 1); + drop_cell(page_contents, 0, usable_space).unwrap(); + assert_eq!(page_contents.cell_count(), 0); let regs = &[Register::Value(Value::Integer(0))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let payload = add_record(0, 0, page, record, &conn); - assert_eq!(page.cell_count(), 1); + let payload = add_record(0, 0, page.clone(), record, &conn); + assert_eq!(page_contents.cell_count(), 1); - let (start, len) = page.cell_get_raw_region(0, usable_space); - let buf = page.as_ptr(); + let (start, len) = page_contents.cell_get_raw_region(0, usable_space); + let buf = page_contents.as_ptr(); assert_eq!(&payload, &buf[start..start + len]); } } @@ -9262,23 +9262,23 @@ mod tests { let page = get_page(2); let page = page.get(); - let page = page.get_contents(); + let page_contents = page.get_contents(); let usable_space = 4096; let regs = &[Register::Value(Value::Integer(0))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let payload = add_record(0, 0, page, record, &conn); + let payload = add_record(0, 0, page.clone(), record, &conn); let regs = &[Register::Value(Value::Integer(1))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let _ = add_record(1, 1, page, record, &conn); + let _ = add_record(1, 1, page.clone(), record, &conn); let regs = &[Register::Value(Value::Integer(2))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let _ = add_record(2, 2, page, record, &conn); + let _ = add_record(2, 2, page.clone(), record, &conn); - drop_cell(page, 1, usable_space).unwrap(); - drop_cell(page, 1, usable_space).unwrap(); + drop_cell(page_contents, 1, usable_space).unwrap(); + drop_cell(page_contents, 1, usable_space).unwrap(); - ensure_cell(page, 0, &payload); + ensure_cell(page_contents, 0, &payload); } #[test] @@ -9288,29 +9288,29 @@ mod tests { let page = get_page(2); let page = page.get(); - let page = page.get_contents(); + let page_contents = page.get_contents(); let usable_space = 4096; let regs = &[Register::Value(Value::Integer(0))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let _ = add_record(0, 0, page, record, &conn); + let _ = add_record(0, 0, page.clone(), record, &conn); let regs = &[Register::Value(Value::Integer(0))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let _ = add_record(0, 0, page, record, &conn); - drop_cell(page, 0, usable_space).unwrap(); + let _ = add_record(0, 0, page.clone(), record, &conn); + drop_cell(page_contents, 0, usable_space).unwrap(); - defragment_page(page, usable_space, 4).unwrap(); + defragment_page(page_contents, usable_space, 4).unwrap(); let regs = &[Register::Value(Value::Integer(0))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let _ = add_record(0, 1, page, record, &conn); + let _ = add_record(0, 1, page.clone(), record, &conn); - drop_cell(page, 0, usable_space).unwrap(); + drop_cell(page_contents, 0, usable_space).unwrap(); let regs = &[Register::Value(Value::Integer(0))]; let record = ImmutableRecord::from_registers(regs, regs.len()); - let _ = add_record(0, 1, page, record, &conn); + let _ = add_record(0, 1, page.clone(), record, &conn); } #[test] @@ -9334,21 +9334,21 @@ mod tests { let page = page.get(); defragment(page.get_contents()); defragment(page.get_contents()); - insert(0, page.get_contents()); + insert(0, page.clone()); drop(0, page.get_contents()); - insert(0, page.get_contents()); + insert(0, page.clone()); drop(0, page.get_contents()); - insert(0, page.get_contents()); + insert(0, page.clone()); defragment(page.get_contents()); defragment(page.get_contents()); drop(0, page.get_contents()); defragment(page.get_contents()); - insert(0, page.get_contents()); + insert(0, page.clone()); drop(0, page.get_contents()); - insert(0, page.get_contents()); - insert(1, page.get_contents()); - insert(1, page.get_contents()); - insert(0, page.get_contents()); + insert(0, page.clone()); + insert(1, page.clone()); + insert(1, page.clone()); + insert(0, page.clone()); drop(3, page.get_contents()); drop(2, page.get_contents()); compute_free_space(page.get_contents(), usable_space); @@ -9379,7 +9379,7 @@ mod tests { run_until_done( || { fill_cell_payload( - page.get().get_contents(), + page.get(), Some(0), &mut payload, 0, @@ -9393,11 +9393,11 @@ mod tests { ) .unwrap(); let page = page.get(); - insert(0, page.get_contents()); + insert(0, page.clone()); defragment(page.get_contents()); - insert(0, page.get_contents()); + insert(0, page.clone()); defragment(page.get_contents()); - insert(0, page.get_contents()); + insert(0, page.clone()); drop(2, page.get_contents()); drop(0, page.get_contents()); let free = compute_free_space(page.get_contents(), usable_space); @@ -9465,7 +9465,7 @@ mod tests { run_until_done( || { fill_cell_payload( - page.get().get_contents(), + page.get(), Some(0), &mut payload, 0, @@ -9817,7 +9817,7 @@ mod tests { while compute_free_space(page.get_contents(), pager.usable_space()) >= size as usize + 10 { - insert_cell(i, size, page.get_contents(), pager.clone()); + insert_cell(i, size, page.clone(), pager.clone()); i += 1; size = (rng.next_u64() % 1024) as u16; } @@ -9868,15 +9868,16 @@ mod tests { } } - fn insert_cell(cell_idx: u64, size: u16, contents: &mut PageContent, pager: Rc) { + fn insert_cell(cell_idx: u64, size: u16, page: PageRef, pager: Rc) { let mut payload = Vec::new(); let regs = &[Register::Value(Value::Blob(vec![0; size as usize]))]; let record = ImmutableRecord::from_registers(regs, regs.len()); let mut fill_cell_payload_state = FillCellPayloadState::Start; + let contents = page.get_contents(); run_until_done( || { fill_cell_payload( - contents, + page.clone(), Some(cell_idx as i64), &mut payload, cell_idx as usize,