Update dependencies

Author: blackbeam

Cargo.toml

@@ -15,30 +15,30 @@ edition = "2018"
 travis-ci = { repository = "blackbeam/rust_mysql_common" }
 
 [dependencies]
-base64 = "0.12"
-bigdecimal = { version = "0.1", features = ["serde"] }
+base64 = "0.13"
+bigdecimal = { version = "0.2", features = ["serde"] }
 bitflags = "1"
 byteorder = "1"
-bytes = "0.5.2"
+bytes = "0.6.0"
 chrono = { version = "0.4", features = ["serde"] }
 flate2 = { version = "1.0", default-features = false }
 lazy_static = "1"
 lexical = "5.2"
-num-bigint = { version = "0.2", features = ["i128"] }
+num-bigint = { version = "0.3" }
 num-traits = { version = "0.2", features = ["i128"] }
 rand = "0.7"
 regex = "1"
 rust_decimal = "1.0"
 sha1 = "0.6"
-sha2 = "0.8"
+sha2 = "0.9"
 time = { version = "0.2", default-features = false, features = ["std"] }
 twox-hash = "1"
 uuid = "0.8"
 serde = "1"
 serde_json = "1"
 
 [dev-dependencies]
-proptest = "0.9.2"
+proptest = "0.10.1"
 
 [profile.bench]
 debug = true

src/crypto/rsa.rs

@@ -162,7 +162,7 @@ impl PublicKey {
 
     /// Returns number of octets in the modulus.
     pub fn num_octets(&self) -> usize {
-        (self.modulus.bits() + 6) >> 3
+        (self.modulus.bits() as usize + 6) >> 3
     }
 
     /// Returns modulus of the public key.

src/named_params.rs

@@ -27,9 +27,9 @@ use self::ParserState::*;
 /// * names of named parameters (if any) in order of appearance in `query`. Same name may
 ///   appear multiple times if named parameter used more than once.
 /// * query string to pass to MySql (named parameters replaced with `?`).
-pub fn parse_named_params<'a>(
-    query: &'a str,
-) -> Result<(Option<Vec<String>>, Cow<'a, str>), MixedParamsError> {
+pub fn parse_named_params(
+    query: &str,
+) -> Result<(Option<Vec<String>>, Cow<'_, str>), MixedParamsError> {
     let mut state = TopLevel;
     let mut have_positional = false;
     let mut cur_param = 0;

src/packets.rs

@@ -569,10 +569,7 @@ impl<'a> ErrPacket<'a> {
 
     /// Returns false if this error packet contains progress report.
     pub fn is_error(&self) -> bool {
-        match *self {
-            ErrPacket::Error(..) => true,
-            _ => false,
-        }
+        matches!(self, ErrPacket::Error(..))
     }
 
     /// Returns true if this error packet contains progress report.

src/proto/codec/error.rs

@@ -6,8 +6,7 @@
 // option. All files in the project carrying such notice may not be copied,
 // modified, or distributed except according to those terms.
 
-use std::fmt;
-use std::io;
+use std::{fmt, io};
 
 #[derive(Debug)]
 pub enum PacketCodecError {

src/proto/codec/mod.rs

@@ -19,18 +19,14 @@ use std::{
     io::Read,
     mem,
     num::NonZeroUsize,
+    ptr::slice_from_raw_parts_mut,
 };
 
 use self::error::PacketCodecError;
 use crate::constants::{DEFAULT_MAX_ALLOWED_PACKET, MAX_PAYLOAD_LEN, MIN_COMPRESS_LENGTH};
 
 pub mod error;
 
-/// Helper that transmutes `&mut [MaybeUninit<u8>]` to `&mut [u8]`.
-pub(crate) unsafe fn transmute_buf(buf: &mut [mem::MaybeUninit<u8>]) -> &mut [u8] {
-    &mut *(buf as *mut [mem::MaybeUninit<u8>] as *mut [u8])
-}
-
 /// Will split given `packet` to MySql packet chunks and write into `dst`.
 ///
 /// Chunk ids will start with given `seq_id`.
@@ -80,7 +76,10 @@ pub fn compress(
                 loop {
                     dst.reserve(max(chunk.len().saturating_sub(read), 1));
                     let dst_buf = &mut dst.bytes_mut()[7 + read..];
-                    match encoder.read(transmute_buf(dst_buf))? {
+                    match encoder.read(&mut *slice_from_raw_parts_mut(
+                        dst_buf.as_mut_ptr(),
+                        dst_buf.len(),
+                    ))? {
                         0 => break,
                         count => read += count,
                     }
@@ -316,8 +315,10 @@ impl CompDecoder {
                             dst.reserve(plain_len.get());
                             unsafe {
                                 let mut decoder = ZlibDecoder::new(&src[..needed.get()]);
-                                decoder.read_exact(transmute_buf(
-                                    &mut dst.bytes_mut()[..plain_len.get()],
+                                let dst_buf = &mut dst.bytes_mut()[..plain_len.get()];
+                                decoder.read_exact(&mut *slice_from_raw_parts_mut(
+                                    dst_buf.as_mut_ptr(),
+                                    dst_buf.len(),
                                 ))?;
                                 dst.advance_mut(plain_len.get());
                             }

src/proto/sync_framed.rs

@@ -13,10 +13,13 @@ use crate::{
     proto::codec::{error::PacketCodecError, PacketCodec},
 };
 
-use std::io::{
-    Error,
-    ErrorKind::{Interrupted, Other},
-    Read, Write,
+use std::{
+    io::{
+        Error,
+        ErrorKind::{Interrupted, Other},
+        Read, Write,
+    },
+    ptr::slice_from_raw_parts_mut,
 };
 
 // stolen from futures-rs
@@ -148,10 +151,10 @@ where
                     Some(item) => return Some(item),
                     None => unsafe {
                         self.in_buf.reserve(1);
-                        match with_interrupt!(self
-                            .stream
-                            .read(super::codec::transmute_buf(self.in_buf.bytes_mut())))
-                        {
+                        match with_interrupt!(self.stream.read(&mut *slice_from_raw_parts_mut(
+                            self.in_buf.bytes_mut().as_mut_ptr(),
+                            self.in_buf.bytes_mut().len()
+                        ))) {
                             Ok(0) => self.eof = true,
                             Ok(x) => {
                                 self.in_buf.advance_mut(x);

src/row/mod.rs

@@ -60,6 +60,11 @@ impl Row {
         self.values.len()
     }
 
+    /// Returns true if the row has a length of 0.
+    pub fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
     /// Returns columns of this row.
     pub fn columns_ref(&self) -> &[Column] {
         &*self.columns

src/scramble.rs

@@ -61,15 +61,15 @@ pub fn scramble_native(nonce: &[u8], password: &[u8]) -> Option<[u8; 20]> {
 pub fn scramble_sha256(nonce: &[u8], password: &[u8]) -> Option<[u8; 32]> {
     fn sha256_1(bytes: impl AsRef<[u8]>) -> [u8; 32] {
         let mut hasher = Sha256::default();
-        hasher.input(bytes.as_ref());
-        to_u8_32(hasher.result())
+        hasher.update(bytes.as_ref());
+        to_u8_32(hasher.finalize())
     }
 
     fn sha256_2(bytes1: impl AsRef<[u8]>, bytes2: impl AsRef<[u8]>) -> [u8; 32] {
         let mut hasher = Sha256::default();
-        hasher.input(bytes1.as_ref());
-        hasher.input(bytes2.as_ref());
-        to_u8_32(hasher.result())
+        hasher.update(bytes1.as_ref());
+        hasher.update(bytes2.as_ref());
+        to_u8_32(hasher.finalize())
     }
 
     if password.is_empty() {

src/value/convert/bigdecimal.rs

@@ -8,6 +8,8 @@
 
 //! This module implements conversion from/to `Value` for `BigDecimal` type.
 
+use std::convert::TryInto;
+
 use bigdecimal::BigDecimal;
 
 use super::{ConvIr, FromValue, FromValueError, ParseIr, Value};
@@ -25,11 +27,11 @@ impl ConvIr<BigDecimal> for ParseIr<BigDecimal> {
             }),
             Value::Float(x) => Ok(ParseIr {
                 value: Value::Float(x),
-                output: x.into(),
+                output: x.try_into().map_err(|_| FromValueError(Value::Float(x)))?,
             }),
             Value::Double(x) => Ok(ParseIr {
                 value: Value::Double(x),
-                output: x.into(),
+                output: x.try_into().map_err(|_| FromValueError(Value::Double(x)))?,
             }),
             Value::Bytes(bytes) => match BigDecimal::parse_bytes(&*bytes, 10) {
                 Some(x) => Ok(ParseIr {