use super::{
BinlogMode, ColumnInfo, ColumnType, DecimalValue, Field, IntegerValue, RowImages, RowValue,
Rows, RowsEvent, RowsKind, TableDefinition,
};
use crate::{Error, Result, error::invalid, events::TableMapEvent, wire::Cursor};
use std::{iter::FusedIterator, sync::Arc};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ReadOp {
Fixed(usize),
Prefixed { width: usize, maximum: u64 },
}
impl ReadOp {
fn read<'a>(self, input: &mut Cursor<'a>) -> Result<&'a [u8]> {
let length = match self {
Self::Fixed(n) => n,
Self::Prefixed { width, maximum } => {
let n = input.le(width)?;
if n > maximum {
return Err(invalid("column length exceeds TABLE_MAP maximum"));
}
usize::try_from(n).map_err(|_| invalid("column length overflows usize"))?
}
};
input.take(length)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ColumnDefinition {
wire_type: ColumnType,
column_type: ColumnType,
nullable: bool,
metadata: [u8; 2],
metadata_len: usize,
read: ReadOp,
}
impl ColumnDefinition {
pub fn wire_type(&self) -> ColumnType {
self.wire_type
}
pub fn column_type(&self) -> ColumnType {
self.column_type
}
pub fn nullable(&self) -> bool {
self.nullable
}
pub fn metadata(&self) -> &[u8] {
&self.metadata[..self.metadata_len]
}
pub fn maximum_length(&self) -> Option<u64> {
match self.read {
ReadOp::Prefixed { maximum, .. } => Some(maximum),
ReadOp::Fixed(_) => None,
}
}
fn value<'a>(&self, input: &mut Cursor<'a>) -> Result<RowValue<'a>> {
use ColumnType::*;
let data = self.read.read(input)?;
Ok(match self.column_type {
MYSQL_TYPE_TINY | MYSQL_TYPE_SHORT | MYSQL_TYPE_LONG | MYSQL_TYPE_INT24
| MYSQL_TYPE_LONGLONG => RowValue::Integer(IntegerValue { data }),
MYSQL_TYPE_FLOAT => RowValue::Float(f32::from_le_bytes(
data.try_into().map_err(|_| invalid("FLOAT width"))?,
)),
MYSQL_TYPE_DOUBLE => RowValue::Double(f64::from_le_bytes(
data.try_into().map_err(|_| invalid("DOUBLE width"))?,
)),
MYSQL_TYPE_NEWDECIMAL => {
RowValue::Decimal(DecimalValue::new(data, self.metadata[0], self.metadata[1])?)
}
MYSQL_TYPE_VARCHAR
| MYSQL_TYPE_VAR_STRING
| MYSQL_TYPE_STRING
| MYSQL_TYPE_TINY_BLOB
| MYSQL_TYPE_MEDIUM_BLOB
| MYSQL_TYPE_LONG_BLOB
| MYSQL_TYPE_BLOB => RowValue::Bytes(data),
MYSQL_TYPE_BIT => {
let bits = usize::from(self.metadata[0]) + usize::from(self.metadata[1]) * 8;
if bits % 8 != 0 && data[0] >> (bits % 8) != 0 {
return Err(invalid("nonzero BIT padding"));
}
RowValue::Bit(data.iter().fold(0, |n, &b| (n << 8) | u64::from(b)))
}
MYSQL_TYPE_ENUM => RowValue::Enum(Cursor::new(data).le(data.len())? as u16),
MYSQL_TYPE_SET => RowValue::Set(Cursor::new(data).le(data.len())?),
MYSQL_TYPE_YEAR => RowValue::Year(if data[0] == 0 {
0
} else {
1900 + u16::from(data[0])
}),
_ => RowValue::Encoded(data),
})
}
}
#[derive(Debug, Clone)]
pub struct RowsDecoder<M: BinlogMode> {
mode: std::marker::PhantomData<M>,
table_id: u64,
table: Arc<TableDefinition>,
}
impl<M: BinlogMode> RowsDecoder<M> {
pub fn new(table: &TableMapEvent<'_>) -> Result<Self> {
let layout = table.columns()?;
validate_bitmap(layout.nullable, layout.count)?;
let mut metadata = Cursor::new(layout.metadata);
let mut columns = Vec::with_capacity(layout.count);
for (index, &ty) in layout.types.iter().enumerate() {
columns.push(compile_column(
ty,
bit(layout.nullable, index),
&mut metadata,
)?);
}
metadata.finish()?;
Ok(Self {
mode: std::marker::PhantomData,
table_id: table.table_id,
table: Arc::new(TableDefinition::new(
table,
columns,
layout.optional_metadata,
)?),
})
}
pub fn table_id(&self) -> u64 {
self.table_id
}
pub fn table(&self) -> &TableDefinition {
&self.table
}
pub fn columns(&self) -> &[ColumnInfo] {
&self.table.columns
}
pub fn rows<'a>(&self, event: &RowsEvent<'a, M>) -> Result<Rows<'a, M>> {
if event.table_id != self.table_id {
return Err(invalid("ROWS table ID differs from TABLE_MAP"));
}
self.rows_from_images(event.kind, event.images()?)
}
pub fn rows_from_images<'a>(
&self,
kind: RowsKind,
images: RowImages<'a>,
) -> Result<Rows<'a, M>> {
M::validate_images(&images)?;
if images.column_count != self.columns().len() {
return Err(invalid("ROWS column count differs from TABLE_MAP"));
}
let first = ImagePlan::new(&self.table, images.before_columns)?;
let plans = match kind {
RowsKind::Write => super::RowOperation::Insert { after: first },
RowsKind::Delete => super::RowOperation::Delete { before: first },
RowsKind::Update => super::RowOperation::Update {
before: first,
after: ImagePlan::new(&self.table, images.after_columns)?,
},
};
if images.rows.is_empty() {
return Err(invalid("ROWS event contains no rows"));
}
Ok(Rows::new(DecodedRows {
input: Cursor::new(images.rows),
plans,
column_count: images.column_count,
}))
}
}
#[derive(Debug)]
struct ImagePlan {
table: Arc<TableDefinition>,
indices: Arc<[u16]>,
columns: Vec<ColumnDefinition>,
}
impl ImagePlan {
fn new(table: &Arc<TableDefinition>, bitmap: &[u8]) -> Result<Arc<Self>> {
let columns = &table.columns;
validate_bitmap(bitmap, columns.len())?;
let mut indices = Vec::new();
let mut present = Vec::new();
for (byte_index, &byte) in bitmap.iter().enumerate() {
let mut bits = byte;
while bits != 0 {
let index = byte_index * 8 + bits.trailing_zeros() as usize;
if index >= columns.len() {
break;
}
indices.push(index as u16);
present.push(columns[index].definition);
bits &= bits - 1;
}
}
if present.is_empty() {
return Err(invalid("empty row image"));
}
Ok(Arc::new(Self {
table: Arc::clone(table),
indices: indices.into(),
columns: present,
}))
}
fn read<'a>(
self: &Arc<Self>,
input: &mut Cursor<'a>,
selected: Option<u16>,
) -> std::result::Result<(RowImage<'a>, Option<RowValue<'a>>), super::RowReadError> {
let nulls = input.take(self.columns.len().div_ceil(8))?;
let start = input.remaining();
let mut selected_value = None;
for (i, column) in self.columns.iter().enumerate() {
let value = if bit(nulls, i) {
if !column.nullable {
return Err(super::RowReadError::UnexpectedNull(self.indices[i]));
}
RowValue::Null
} else {
column.value(input)?
};
if selected.is_some_and(|index| index == self.indices[i]) {
selected_value = Some(value);
}
}
Ok((
RowImage {
plan: Arc::clone(self),
nulls,
data: &start[..start.len() - input.remaining().len()],
},
selected_value,
))
}
}
#[derive(Debug, Clone)]
pub struct RowImage<'a> {
plan: Arc<ImagePlan>,
nulls: &'a [u8],
data: &'a [u8],
}
impl<'a> RowImage<'a> {
pub fn column_count(&self) -> usize {
self.plan.table.columns.len()
}
pub fn table(&self) -> &TableDefinition {
&self.plan.table
}
pub fn columns(&self) -> &[ColumnInfo] {
&self.plan.table.columns
}
pub fn column_indices(&self) -> &[u16] {
&self.plan.indices
}
pub fn fields(&self) -> Fields<'_, 'a> {
Fields {
plan: &self.plan,
nulls: self.nulls,
input: Cursor::new(self.data),
index: 0,
done: false,
}
}
pub fn retained_bytes(&self) -> usize {
retained_size(&self.plan, self.nulls.len() + self.data.len())
}
pub fn into_owned(self) -> OwnedRowImage {
let null_bytes = self.nulls.len();
let mut data = Vec::with_capacity(null_bytes + self.data.len());
data.extend_from_slice(self.nulls);
data.extend_from_slice(self.data);
OwnedRowImage {
plan: self.plan,
data: data.into_boxed_slice(),
null_bytes,
}
}
}
#[derive(Debug, Clone)]
pub struct OwnedRowImage {
plan: Arc<ImagePlan>,
data: Box<[u8]>,
null_bytes: usize,
}
impl OwnedRowImage {
pub fn view(&self) -> RowImage<'_> {
RowImage {
plan: Arc::clone(&self.plan),
nulls: &self.data[..self.null_bytes],
data: &self.data[self.null_bytes..],
}
}
pub fn column_indices(&self) -> &[u16] {
&self.plan.indices
}
pub fn columns(&self) -> &[ColumnInfo] {
&self.plan.table.columns
}
pub fn fields(&self) -> Fields<'_, '_> {
Fields {
plan: &self.plan,
nulls: &self.data[..self.null_bytes],
input: Cursor::new(&self.data[self.null_bytes..]),
index: 0,
done: false,
}
}
pub fn retained_bytes(&self) -> usize {
retained_size(&self.plan, self.data.len())
}
}
fn retained_size(plan: &ImagePlan, data_len: usize) -> usize {
data_len
+ std::mem::size_of::<ImagePlan>()
+ 4 * std::mem::size_of::<usize>()
+ plan.indices.len() * std::mem::size_of::<u16>()
+ plan.columns.capacity() * std::mem::size_of::<ColumnDefinition>()
}
pub struct Fields<'image, 'event> {
plan: &'image ImagePlan,
nulls: &'event [u8],
input: Cursor<'event>,
index: usize,
done: bool,
}
impl<'image, 'event> Iterator for Fields<'image, 'event> {
type Item = Result<Field<'image, 'event>>;
fn next(&mut self) -> Option<Self::Item> {
if self.done {
return None;
}
let column = self.plan.columns.get(self.index)?;
let value = if bit(self.nulls, self.index) {
Ok(RowValue::Null)
} else {
column.value(&mut self.input)
};
let result = value.map(|value| Field {
column: &self.plan.table.columns[usize::from(self.plan.indices[self.index])],
value,
});
self.index += 1;
self.done = result.is_err();
Some(result)
}
}
impl FusedIterator for Fields<'_, '_> {}
pub(crate) struct DecodedRows<'a> {
input: Cursor<'a>,
plans: super::RowOperation<Arc<ImagePlan>>,
column_count: usize,
}
impl<'a> DecodedRows<'a> {
pub(crate) fn read<T>(
&mut self,
selected: Option<u16>,
map: impl Fn(RowImage<'a>, Option<RowValue<'a>>) -> Result<T>,
) -> Option<std::result::Result<super::RowOperation<T>, super::RowReadError>> {
if self.input.remaining().is_empty() {
return None;
}
Some((|| {
if selected.is_some_and(|i| usize::from(i) >= self.column_count) {
return Err(invalid("selected column outside row image").into());
}
let mut read = |plan: &Arc<ImagePlan>| {
let (image, value) = plan.read(&mut self.input, selected)?;
map(image, value).map_err(super::RowReadError::from)
};
use super::RowOperation::*;
Ok(match &self.plans {
Insert { after } => Insert {
after: read(after)?,
},
Update { before, after } => Update {
before: read(before)?,
after: read(after)?,
},
Delete { before } => Delete {
before: read(before)?,
},
})
})())
}
}
fn bit(bitmap: &[u8], index: usize) -> bool {
bitmap[index / 8] & (1 << (index % 8)) != 0
}
fn validate_bitmap(bitmap: &[u8], count: usize) -> Result<()> {
if bitmap.len() != count.div_ceil(8) {
return Err(invalid("column bitmap length"));
}
Ok(())
}
fn compile_column(ty: u8, nullable: bool, metadata: &mut Cursor<'_>) -> Result<ColumnDefinition> {
use ColumnType::*;
use ReadOp::*;
let wire_type = ColumnType::try_from(ty)
.map_err(|_| Error::Unsupported(format!("wire column type {ty}")))?;
let start = metadata.remaining();
let mut column_type = wire_type;
let mut m = [0; 2];
let string = |maximum| Prefixed {
width: if maximum < 256 { 1 } else { 2 },
maximum,
};
let read = match wire_type {
MYSQL_TYPE_TINY | MYSQL_TYPE_YEAR => Fixed(1),
MYSQL_TYPE_SHORT => Fixed(2),
MYSQL_TYPE_LONG | MYSQL_TYPE_TIMESTAMP => Fixed(4),
MYSQL_TYPE_LONGLONG | MYSQL_TYPE_DATETIME => Fixed(8),
MYSQL_TYPE_INT24 | MYSQL_TYPE_DATE | MYSQL_TYPE_NEWDATE | MYSQL_TYPE_TIME => Fixed(3),
MYSQL_TYPE_FLOAT | MYSQL_TYPE_DOUBLE => {
m[0] = metadata.byte()?;
let width = if wire_type == MYSQL_TYPE_FLOAT { 4 } else { 8 };
if usize::from(m[0]) != width {
return Err(invalid("FLOAT/DOUBLE metadata width"));
}
Fixed(width)
}
MYSQL_TYPE_VARCHAR | MYSQL_TYPE_VAR_STRING => {
m.copy_from_slice(metadata.take(2)?);
string(u64::from(u16::from_le_bytes(m)))
}
MYSQL_TYPE_BIT => {
m.copy_from_slice(metadata.take(2)?);
let bits = usize::from(m[0]) + usize::from(m[1]) * 8;
if m[0] > 7 || bits == 0 || bits > 64 {
return Err(invalid("BIT metadata width"));
}
Fixed(bits.div_ceil(8))
}
MYSQL_TYPE_TIMESTAMP2 | MYSQL_TYPE_DATETIME2 | MYSQL_TYPE_TIME2 => {
m[0] = metadata.byte()?;
if m[0] > 6 {
return Err(invalid("temporal precision exceeds 6"));
}
let width = match wire_type {
MYSQL_TYPE_TIMESTAMP2 => 4,
MYSQL_TYPE_DATETIME2 => 5,
_ => 3,
};
Fixed(width + usize::from(m[0]).div_ceil(2))
}
MYSQL_TYPE_NEWDECIMAL => {
m.copy_from_slice(metadata.take(2)?);
if m[0] == 0 || m[0] > 65 || m[1] > m[0] || m[1] > 30 {
return Err(invalid("DECIMAL precision/scale"));
}
let integral = usize::from(m[0] - m[1]);
let scale = usize::from(m[1]);
Fixed(
integral / 9 * 4
+ super::value::decimal_group_size(integral % 9)
+ scale / 9 * 4
+ super::value::decimal_group_size(scale % 9),
)
}
MYSQL_TYPE_ENUM | MYSQL_TYPE_SET | MYSQL_TYPE_STRING => {
m.copy_from_slice(metadata.take(2)?);
if wire_type == MYSQL_TYPE_STRING {
column_type = match m[0] | 0x30 {
247 => MYSQL_TYPE_ENUM,
248 => MYSQL_TYPE_SET,
254 => MYSQL_TYPE_STRING,
_ if m[0] == 0 => MYSQL_TYPE_STRING,
_ => return Err(invalid("invalid STRING real type")),
};
}
if matches!(column_type, MYSQL_TYPE_ENUM | MYSQL_TYPE_SET) {
let width = usize::from(m[1]);
if width == 0 || width > if column_type == MYSQL_TYPE_ENUM { 2 } else { 8 } {
return Err(invalid("ENUM/SET width"));
}
Fixed(width)
} else {
let maximum = if m[0] == 0 {
u64::from(m[1]) << 8
} else {
u64::from(m[1]) | (u64::from((m[0] & 0x30) ^ 0x30) << 4)
};
string(maximum)
}
}
MYSQL_TYPE_JSON
| MYSQL_TYPE_TINY_BLOB
| MYSQL_TYPE_MEDIUM_BLOB
| MYSQL_TYPE_LONG_BLOB
| MYSQL_TYPE_BLOB
| MYSQL_TYPE_GEOMETRY
| MYSQL_TYPE_VECTOR => {
m[0] = metadata.byte()?;
let width = usize::from(m[0]);
if !(1..=4).contains(&width) || wire_type == MYSQL_TYPE_JSON && width != 4 {
return Err(invalid("BLOB/JSON length-prefix width"));
}
Prefixed {
width,
maximum: (1u64 << (width * 8)) - 1,
}
}
_ => return Err(Error::Unsupported(format!("wire column type {ty}"))),
};
Ok(ColumnDefinition {
wire_type,
column_type,
nullable,
metadata: m,
metadata_len: start.len() - metadata.remaining().len(),
read,
})
}