Merge branch 'master' into basic_tls_support_2

Author: mjgarton

Cargo.toml

@@ -28,7 +28,7 @@ maintenance = { status = "experimental" }
 
 [dependencies]
 nom = "5"
-mysql_common = "0.22"
+mysql_common = { version = "0.28.0", features = ["chrono"] }
 byteorder = "1"
 chrono = "0.4"
 time = "0.2.25"

examples/psql_as_mysql.rs

@@ -9,6 +9,7 @@ extern crate slab;
 
 use msql_srv::*;
 use mysql::prelude::*;
+use mysql::Opts;
 use slab::Slab;
 
 use std::io;
@@ -29,7 +30,8 @@ fn main() {
     });
 
     // we connect using MySQL bindings, but no MySQL server is running!
-    let mut db = mysql::Conn::new(&format!("mysql://127.0.0.1:{}", port)).unwrap();
+    let mut db =
+        mysql::Conn::new(Opts::from_url(&format!("mysql://127.0.0.1:{}", port)).unwrap()).unwrap();
     assert_eq!(db.ping(), true);
     {
         let mut results = db

src/lib.rs

@@ -20,6 +20,7 @@
 //! # use std::thread;
 //! use msql_srv::*;
 //! use mysql::prelude::*;
+//! use mysql::Opts;
 //!
 //! struct Backend;
 //! impl<W: io::Read + io::Write> MysqlShim<W> for Backend {
@@ -73,7 +74,7 @@
 //!         }
 //!     });
 //!
-//!     let mut db = mysql::Conn::new(&format!("mysql://127.0.0.1:{}", port)).unwrap();
+//!     let mut db = mysql::Conn::new(Opts::from_url(&format!("mysql://127.0.0.1:{}", port)).unwrap()).unwrap();
 //!     assert_eq!(db.ping(), true);
 //!     assert_eq!(db.query_iter("SELECT a, b FROM foo").unwrap().count(), 1);
 //!     drop(db);

src/params.rs

@@ -1,6 +1,7 @@
 use crate::myc;
 use crate::{StatementData, Value};
 use std::collections::HashMap;
+use std::convert::TryFrom;
 
 /// A `ParamParser` decodes query parameters included in a client's `EXECUTE` command given
 /// type information for the expected parameters.
@@ -72,7 +73,10 @@ impl<'a> Iterator for Params<'a> {
                 self.bound_types.clear();
                 for i in 0..self.params as usize {
                     self.bound_types.push((
-                        myc::constants::ColumnType::from(typmap[2 * i as usize]),
+                        myc::constants::ColumnType::try_from(typmap[2 * i as usize])
+                            .unwrap_or_else(|e| {
+                                panic!("bad column type 0x{:x}: {}", typmap[2 * i as usize], e)
+                            }),
                         (typmap[2 * i as usize + 1] & 128) != 0,
                     ));
                 }

src/value/decode.rs

@@ -286,6 +286,7 @@ mod tests {
     use crate::myc::io::WriteMysqlExt;
     use crate::{Column, ColumnFlags, ColumnType};
     use chrono::{self, TimeZone};
+    use myc::proto::MySerialize;
     use std::time;
 
     macro_rules! rt {
@@ -308,7 +309,7 @@ mod tests {
                 }
 
                 let v: $t = $v;
-                data.write_bin_value(&myc::value::Value::from(v)).unwrap();
+                myc::value::Value::from(v).serialize(&mut data);
                 assert_eq!(
                     Into::<$t>::into(Value::parse_from(&mut &data[..], $ct, !$sig).unwrap()),
                     v

src/value/encode.rs

@@ -1,4 +1,3 @@
-use crate::myc;
 use crate::myc::constants::{ColumnFlags, ColumnType};
 use crate::myc::io::WriteMysqlExt;
 use crate::Column;
@@ -663,22 +662,34 @@ mod tests {
     use super::ToMysqlValue;
     use crate::myc::value;
     use crate::myc::value::convert::from_value;
+    use crate::myc::value::Value;
     use crate::{Column, ColumnFlags, ColumnType};
     use chrono::{self, TimeZone};
     use std::time;
 
     mod roundtrip_text {
         use super::*;
 
+        use myc::{
+            io::ParseBuf,
+            proto::MyDeserialize,
+            value::{convert::FromValue, TextValue, ValueDeserializer},
+        };
+
         macro_rules! rt {
             ($name:ident, $t:ty, $v:expr) => {
                 #[test]
                 fn $name() {
                     let mut data = Vec::new();
                     let v: $t = $v;
                     v.to_mysql_text(&mut data).unwrap();
+                    let mut pb = ParseBuf(&mut data[..]);
                     assert_eq!(
-                        from_value::<$t>(value::read_text_value(&mut &data[..]).unwrap()),
+                        <$t>::from_value(
+                            ValueDeserializer::<TextValue>::deserialize((), &mut pb)
+                                .unwrap()
+                                .0,
+                        ),
                         v
                     );
                 }
@@ -728,6 +739,12 @@ mod tests {
     mod roundtrip_bin {
         use super::*;
 
+        use myc::{
+            io::ParseBuf,
+            proto::MyDeserialize,
+            value::{convert::FromValue, BinValue, ValueDeserializer},
+        };
+
         macro_rules! rt {
             ($name:ident, $t:ty, $v:expr, $ct:expr) => {
                 rt!($name, $t, $v, $ct, false);
@@ -749,9 +766,22 @@ mod tests {
 
                     let v: $t = $v;
                     v.to_mysql_bin(&mut data, &col).unwrap();
+                    let mut pb = ParseBuf(&mut data[..]);
                     assert_eq!(
-                        from_value::<$t>(
-                            value::read_bin_value(&mut &data[..], $ct, !$sig).unwrap()
+                        <$t>::from_value(
+                            ValueDeserializer::<BinValue>::deserialize(
+                                (
+                                    $ct,
+                                    if $sig {
+                                        ColumnFlags::empty()
+                                    } else {
+                                        ColumnFlags::UNSIGNED_FLAG
+                                    }
+                                ),
+                                &mut pb
+                            )
+                            .unwrap()
+                            .0,
                         ),
                         v
                     );

tests/main.rs

@@ -161,6 +161,7 @@ where
             .ssl_opts(client_tls);
 
         let mut db = mysql::Conn::new(opts)?;
+
         c(&mut db);
         drop(db);
         jh.join().unwrap().unwrap();