Merge pull request #175 from blackbeam/v0.36.0-release

v0.36.0 release

Author: blackbeam

Cargo.toml

@@ -13,7 +13,7 @@ keywords = ["mysql", "database"]
 categories = ["database"]
 
 # * Invoke `cargo readme > README.md` if relevant!
-version = "0.35.5"
+version = "0.36.0"
 
 edition = "2024"
 exclude = [
@@ -61,7 +61,7 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 
 mysql-common-derive = { path = "derive", version = "0.32.0", optional = true }
-btoi = "0.4.3"
+btoi = "0.5"
 zstd = { version = "0.13", optional = true }
 
 [dev-dependencies]
@@ -70,7 +70,7 @@ proptest = "1.0"
 unic-langid = { version = "0.9.4" }
 
 [build-dependencies]
-bindgen = { version = "0.71", default-features = false, features = [
+bindgen = { version = "0.72", default-features = false, features = [
     "runtime",
 ], optional = true }
 cc = { version = "1.0", optional = true }

src/binlog/events/format_description_event.rs

@@ -38,29 +38,29 @@ define_const!(
 
 /// A format description event is the first event of a binlog for binlog-version 4.
 ///
-/// It describes how the other events are layed out.
+/// It describes how other events are laid out.
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct FormatDescriptionEvent<'a> {
     /// Version of this binlog format.
     binlog_version: Const<BinlogVersion, LeU16>,
     /// Version of the MySQL Server that created the binlog (len=50).
     ///
-    /// The string is evaluted to apply work-arounds in the slave.
+    /// The string is evaluated to apply workarounds in the slave.
     server_version: RawBytes<'a, FixedLengthText<{ SERVER_VER_LEN }>>,
     /// Seconds since Unix epoch when the binlog was created.
     create_timestamp: RawInt<LeU32>,
-    /// Event header length. Aloway `19`.
+    /// Event header length. Always `19`.
     event_header_length: EventHeaderLength,
     /// An array indexed by Binlog Event Type - 1 to extract the length of the event specific
     /// header.
     ///
     /// Use [`Self::get_event_type_header_length`] to get header length for particular event type.
     event_type_header_lengths: RawBytes<'a, EofBytes>,
-    /// This event structure also stores a footer containig checksum algorithm description.
+    /// This event structure also stores a footer containing checksum algorithm description.
     ///
     /// # Note
     ///
-    /// Footer must be assigned manualy after `Self::read`
+    /// Footer must be assigned manually after `Self::read`
     footer: BinlogEventFooter,
 }
 
@@ -236,7 +236,7 @@ impl<'a> FormatDescriptionEvent<'a> {
             .as_bytes()
             .get(usize::from(event_type as u8).saturating_sub(1))
             .copied()
-            .unwrap_or_else(|| match event_type {
+            .unwrap_or(match event_type {
                 EventType::UNKNOWN_EVENT => 0,
                 EventType::START_EVENT_V3 => Self::START_V3_HEADER_LEN,
                 EventType::QUERY_EVENT => Self::QUERY_HEADER_LEN,

src/binlog/events/mod.rs

@@ -48,7 +48,6 @@ use std::{
     borrow::Cow,
     cmp::min,
     io::{self, Read, Write},
-    u16,
 };
 
 use super::{
@@ -245,13 +244,10 @@ impl Event {
 
         // it is an error if the `event_data` isn't fully consumed
         if !event_data.is_empty() {
-            return Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!(
-                    "bytes remaining on stream while reading {}",
-                    type_name::<T>()
-                ),
-            ));
+            return Err(io::Error::other(format!(
+                "bytes remaining on stream while reading {}",
+                type_name::<T>()
+            )));
         }
 
         Ok(event)

src/binlog/events/rows_event.rs

@@ -145,7 +145,7 @@ impl<'a> RowsEvent<'a> {
         len += S(2); // extra-data len
         len += S(min(self.extra_data.len(), u16::MAX as usize - 2)); // extra data
         len += S(crate::misc::lenenc_int_len(self.num_columns()) as usize); // number of columns
-        let bitmap_len = (self.num_columns() as usize + 7) / 8;
+        let bitmap_len = self.num_columns().div_ceil(8) as usize;
         if self.columns_before_image.is_some() {
             len += S(bitmap_len); // columns present bitmap 1
         }
@@ -229,7 +229,7 @@ impl<'de> MyDeserialize<'de> for RowsEvent<'de> {
         };
 
         let num_columns: RawInt<LenEnc> = buf.parse(())?;
-        let bitmap_len = (num_columns.0 as usize + 7) / 8;
+        let bitmap_len = num_columns.0.div_ceil(8) as usize;
 
         let mut columns_before_image = None;
         let mut columns_after_image = None;

src/binlog/events/table_map_event.rs

@@ -93,7 +93,7 @@ impl<'a> TableMapEvent<'a> {
         self.columns_count.0
     }
 
-    /// Ruturns a number of JSON columns.
+    /// Returns a number of JSON columns.
     pub fn json_column_count(&self) -> usize {
         self.columns_type
             .0
@@ -265,7 +265,7 @@ impl<'de> MyDeserialize<'de> for TableMapEvent<'de> {
         let columns_count: RawInt<LenEnc> = buf.parse(())?;
         let columns_type = buf.parse(columns_count.0 as usize)?;
         let columns_metadata = buf.parse(())?;
-        let null_bitmask = buf.parse(((columns_count.0 + 7) / 8) as usize)?;
+        let null_bitmask = buf.parse(columns_count.0.div_ceil(8) as usize)?;
         let optional_metadata = buf.parse(())?;
 
         Ok(TableMapEvent {
@@ -328,8 +328,8 @@ impl<'a> BinlogStruct<'a> for TableMapEvent<'a> {
 
 /// Optional metadata field that contains charsets for columns.
 ///
-/// - contains charsets for caracter columns if it's a [`OptionalMetadataField::DefaultCharset`];
-/// – contains charsets for ENUM and SET columns if it's a
+/// * contains charsets for character columns if it's a [`OptionalMetadataField::DefaultCharset`];
+/// * contains charsets for ENUM and SET columns if it's a
 ///   [`OptionalMetadataField::EnumAndSetDefaultCharset`].
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct DefaultCharset<'a> {
@@ -449,8 +449,8 @@ impl MySerialize for NonDefaultCharset {
 
 /// Contains charset+collation for column.
 ///
-/// - contains charsets for caracter columns if it's a [`OptionalMetadataField::ColumnCharset`];
-/// – contains charsets for ENUM and SET columns if it's a
+/// * contains charsets for character columns if it's a [`OptionalMetadataField::ColumnCharset`];
+/// * contains charsets for ENUM and SET columns if it's a
 ///   [`OptionalMetadataField::EnumAndSetColumnCharset`].
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct ColumnCharsets<'a> {
@@ -1215,7 +1215,7 @@ pub struct OptionalMetadataIter<'a> {
 
 impl<'a> OptionalMetadataIter<'a> {
     /// Reads type-length-value value.
-    fn read_tlv(&mut self) -> io::Result<(RawConst<u8, OptionalMetadataFieldType>, &'a [u8])> {
+    fn read_tlv(&mut self) -> io::Result<(u8, &'a [u8])> {
         let t = self.data.read_u8()?;
         // The length is encoded in 1, 3 or 8 bytes (https://github.com/mysql/mysql-server/blob/824e2b4064053f7daf17d7f3f84b7a3ed92e5fb4/libs/mysql/binlog/event/binlog_event.h#L812)
         let l = self.data.read_lenenc_int()? as usize;
@@ -1230,13 +1230,11 @@ impl<'a> OptionalMetadataIter<'a> {
             }
         };
         self.data = &self.data[l..];
-        Ok((RawConst::new(t), v))
+        Ok((t, v))
     }
 
     /// Returns next tlv, if any.
-    fn next_tlv(
-        &mut self,
-    ) -> Option<io::Result<(RawConst<u8, OptionalMetadataFieldType>, &'a [u8])>> {
+    fn next_tlv(&mut self) -> Option<io::Result<(u8, &'a [u8])>> {
         if self.data.is_empty() {
             return None;
         }
@@ -1266,19 +1264,17 @@ impl<'a> Iterator for OptionalMetadataIter<'a> {
 
         self.next_tlv()?
             .and_then(|(t, v)| {
+                let t = RawConst::<u8, OptionalMetadataFieldType>::new(t);
                 let mut v = ParseBuf(v);
                 match t.get() {
                     Ok(t) => match t {
                         SIGNEDNESS => {
                             let num_numeric = self.count_columns(ColumnType::is_numeric_type);
-                            let num_flags_bytes = (num_numeric + 7) / 8;
+                            let num_flags_bytes = num_numeric.div_ceil(8);
                             let flags: &[u8] = v.parse(num_flags_bytes)?;
 
                             if !v.is_empty() {
-                                return Err(io::Error::new(
-                                    io::ErrorKind::Other,
-                                    "bytes remaining on stream",
-                                ));
+                                return Err(io::Error::other("bytes remaining on stream"));
                             }
 
                             let flags = BitSlice::from_slice(flags);
@@ -1304,14 +1300,11 @@ impl<'a> Iterator for OptionalMetadataIter<'a> {
                         }
                         COLUMN_VISIBILITY => {
                             let num_columns = self.num_columns();
-                            let num_flags_bytes = (num_columns + 7) / 8;
+                            let num_flags_bytes = num_columns.div_ceil(8);
                             let flags: &[u8] = v.parse(num_flags_bytes)?;
 
                             if !v.is_empty() {
-                                return Err(io::Error::new(
-                                    io::ErrorKind::Other,
-                                    "bytes remaining on stream",
-                                ));
+                                return Err(io::Error::other("bytes remaining on stream"));
                             }
 
                             let flags = BitSlice::from_slice(flags);
@@ -1453,7 +1446,7 @@ impl<'a> OptionalMetaExtractor<'a> {
     ///
     /// Returns peekable iterator so that it is possible to observe next PK index.
     ///
-    /// Emits nothing if there are no PK data in the optinal metadata.
+    /// Emits nothing if there are no PK data in the optional metadata.
     pub fn iter_primary_key(&'a self) -> Peekable<impl Iterator<Item = io::Result<u64>> + 'a> {
         let simple = self
             .simple_primary_key

src/binlog/events/transaction_payload_event.rs

@@ -80,7 +80,7 @@ impl io::BufRead for TransactionPayloadReader<'_> {
     }
 }
 
-/// Wraps the data providing [`io::BufRead`] implementaion.
+/// Wraps the data providing [`io::BufRead`] implementation.
 enum TransactionPayloadInner<'a> {
     Uncompressed(&'a [u8]),
     ZstdCompressed(BufReader<zstd::Decoder<'a, &'a [u8]>>),
@@ -209,7 +209,7 @@ impl<'a> TransactionPayloadEvent<'a> {
             ));
         }
 
-        return TransactionPayloadReader::new_zstd(self.payload_raw());
+        TransactionPayloadReader::new_zstd(self.payload_raw())
     }
 
     /// Decompress the whole payload.

src/binlog/jsonb.rs

@@ -792,15 +792,14 @@ impl<'a> Value<'a> {
                     )))
                 }
                 ColumnType::MYSQL_TYPE_TIME => {
-                    let packed_value = dbg!(opaque_value.data_raw())
-                        .first_chunk::<8>()
-                        .ok_or_else(|| {
+                    let packed_value =
+                        opaque_value.data_raw().first_chunk::<8>().ok_or_else(|| {
                             io::Error::new(
                                 io::ErrorKind::InvalidData,
                                 "not enough data to decode MYSQL_TYPE_TIME",
                             )
                         })?;
-                    let packed_value = dbg!(i64::from_le_bytes(*packed_value));
+                    let packed_value = i64::from_le_bytes(*packed_value);
                     Ok(JsonDom::Scalar(JsonScalar::DateTime(
                         MysqlTime::from_int64_time_packed(packed_value),
                     )))