Struct UndoLogHeader 

pub struct UndoLogHeader {
    pub trx_id: u64,
    pub trx_no: u64,
    pub del_marks: bool,
    pub log_start: u16,
    pub xid_exists: bool,
    pub dict_trans: bool,
    pub table_id: u64,
    pub next_log: u16,
    pub prev_log: u16,
}

Parsed undo log record header (at the start of an undo log within the page).

Fields

trx_id: u64

Transaction ID that created this undo log.

trx_no: u64

Transaction serial number.

del_marks: bool

Whether delete marks exist in this undo log.

log_start: u16

Offset of the first undo log record.

xid_exists: bool

Whether XID info exists (distributed transactions).

dict_trans: bool

Whether this is a DDL transaction.

table_id: u64

Table ID (for insert undo logs).

next_log: u16

Offset of the next undo log header (0 if last).

prev_log: u16

Offset of the previous undo log header (0 if first).

Implementations

impl UndoLogHeader

pub fn parse(page_data: &[u8], log_offset: usize) -> Option<Self>

Parse an undo log header from a page at the given offset.

The log_offset is typically obtained from UndoSegmentHeader::last_log or UndoPageHeader::start.

Examples

use idb::innodb::undo::UndoLogHeader;
use byteorder::{BigEndian, ByteOrder};

// The undo log header is 34 bytes starting at log_offset.
let log_offset = 100;
let mut page = vec![0u8; log_offset + 34];

// trx_id (8 bytes) at offset 0
BigEndian::write_u64(&mut page[log_offset..], 1001);
// trx_no (8 bytes) at offset 8
BigEndian::write_u64(&mut page[log_offset + 8..], 500);
// del_marks (2 bytes) at offset 16
BigEndian::write_u16(&mut page[log_offset + 16..], 1);
// log_start (2 bytes) at offset 18
BigEndian::write_u16(&mut page[log_offset + 18..], 120);
// xid_exists (1 byte) at offset 20
page[log_offset + 20] = 1;
// dict_trans (1 byte) at offset 21
page[log_offset + 21] = 0;
// table_id (8 bytes) at offset 22
BigEndian::write_u64(&mut page[log_offset + 22..], 42);
// next_log (2 bytes) at offset 30
BigEndian::write_u16(&mut page[log_offset + 30..], 0);
// prev_log (2 bytes) at offset 32
BigEndian::write_u16(&mut page[log_offset + 32..], 0);

let hdr = UndoLogHeader::parse(&page, log_offset).unwrap();
assert_eq!(hdr.trx_id, 1001);
assert_eq!(hdr.trx_no, 500);
assert!(hdr.del_marks);
assert_eq!(hdr.log_start, 120);
assert!(hdr.xid_exists);
assert!(!hdr.dict_trans);
assert_eq!(hdr.table_id, 42);
assert_eq!(hdr.next_log, 0);
assert_eq!(hdr.prev_log, 0);

Trait Implementations

impl Clone for UndoLogHeader

fn clone(&self) -> UndoLogHeader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UndoLogHeader

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

Formats the value using the given formatter.

impl Serialize for UndoLogHeader

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.