Struct CommonEventHeader 

pub struct CommonEventHeader {
    pub timestamp: u32,
    pub type_code: BinlogEventType,
    pub server_id: u32,
    pub event_length: u32,
    pub next_position: u32,
    pub flags: u16,
}

The 19-byte common header present at the start of every binlog event.

All integer fields are stored in little-endian byte order.

Examples

use idb::binlog::CommonEventHeader;
use byteorder::{LittleEndian, ByteOrder};

let mut data = vec![0u8; 19];
LittleEndian::write_u32(&mut data[0..], 1_700_000_000);  // timestamp
data[4] = 15;                                             // FORMAT_DESCRIPTION_EVENT
LittleEndian::write_u32(&mut data[5..], 1);               // server_id
LittleEndian::write_u32(&mut data[9..], 119);             // event_length
LittleEndian::write_u32(&mut data[13..], 123);            // next_position
LittleEndian::write_u16(&mut data[17..], 0);              // flags

let hdr = CommonEventHeader::parse(&data).unwrap();
assert_eq!(hdr.timestamp, 1_700_000_000);
assert_eq!(hdr.event_length, 119);

Fields

timestamp: u32

Seconds since Unix epoch when the event was created.

type_code: BinlogEventType

Event type.

server_id: u32

Server ID of the originating MySQL server.

event_length: u32

Total event size in bytes (header + payload + optional checksum).

next_position: u32

Absolute file position of the next event.

flags: u16

Event flags (e.g. LOG_EVENT_BINLOG_IN_USE_F).

Implementations

impl CommonEventHeader

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

Parse a common event header from a byte slice.

Returns None if the slice is shorter than COMMON_HEADER_SIZE (19 bytes).

pub fn payload_offset(&self) -> usize

Byte offset where the event payload begins (always 19).

pub fn payload_length(&self, checksum_enabled: bool) -> usize

Size of the event payload in bytes, excluding header and optional checksum.

Trait Implementations

impl Clone for CommonEventHeader

fn clone(&self) -> CommonEventHeader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CommonEventHeader

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

Formats the value using the given formatter.

impl Serialize for CommonEventHeader

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

where __S: Serializer,

Serialize this value into the given Serde serializer.