Struct RedundantRecordHeader 

pub struct RedundantRecordHeader {
    pub n_owned: u8,
    pub delete_mark: bool,
    pub min_rec: bool,
    pub heap_no: u16,
    pub rec_type: RecordType,
    pub next_offset: u16,
    pub n_fields: u16,
    pub one_byte_offs: bool,
}

Parsed redundant (old-style) record header.

In redundant format, 6 bytes precede each record:

• Byte 0: info bits (delete mark, min_rec flag) + n_owned
• Bytes 1-2: heap_no (13 bits) + rec_type (3 bits)
• Bytes 2-3: n_fields (10 bits) + one_byte_offs flag (1 bit) (overlaps byte 2)
• Bytes 4-5: next record offset (unsigned, absolute within page)

Fields

n_owned: u8

Number of records owned by this record in the page directory.

delete_mark: bool

Delete mark flag.

min_rec: bool

Min-rec flag (leftmost record on a non-leaf level).

heap_no: u16

Record’s position in the heap.

rec_type: RecordType

Record type.

next_offset: u16

Absolute offset to the next record within the page (unsigned).

n_fields: u16

Number of fields in this record.

one_byte_offs: bool

Whether field end offsets use 1 byte (true) or 2 bytes (false).

Implementations

impl RedundantRecordHeader

pub fn parse(data: &[u8]) -> Option<Self>

Parse a redundant record header from the 6 bytes preceding the record origin.

data should point to the start of the 6-byte extra header.

Examples

use idb::innodb::record::{RedundantRecordHeader, RecordType};
use byteorder::{BigEndian, ByteOrder};

let mut data = vec![0u8; 6];
// byte 0: info_bits(4) | n_owned(4) — n_owned=1, no flags
data[0] = 0x01;
// bytes 1-2: heap_no=5, rec_type=Ordinary(0) => (5 << 3) | 0 = 40
BigEndian::write_u16(&mut data[1..3], 5 << 3);
// bytes 2-3: n_fields=3, one_byte_offs=true => (3 << 6) | 0x20 = 0x00E0
// But byte 2 is shared — we set bytes 2-3 after bytes 1-2
// For this test, set byte 3 separately to encode n_fields in lower byte
data[3] = (3 << 6) as u8; // n_fields low bits + one_byte_offs=0
// bytes 4-5: next_offset = 200 (absolute)
BigEndian::write_u16(&mut data[4..6], 200);

let hdr = RedundantRecordHeader::parse(&data).unwrap();
assert_eq!(hdr.n_owned, 1);
assert!(!hdr.delete_mark);
assert_eq!(hdr.heap_no, 5);
assert_eq!(hdr.rec_type, RecordType::Ordinary);
assert_eq!(hdr.next_offset, 200);

Trait Implementations

impl Clone for RedundantRecordHeader

fn clone(&self) -> RedundantRecordHeader

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RedundantRecordHeader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.