Merge pull request jonhoo#24 from mjgarton/update_postgres_dep

Update postgres dependency

Author: jonhoo

Cargo.toml

@@ -30,7 +30,7 @@ chrono = "0.4"
 time = "0.2.25"
 
 [dev-dependencies]
-postgres = "0.15"
+postgres = "0.19.1"
 mysql = "18"
 mysql_async = "0.20.0"
 slab = "0.4.2"

azure-pipelines.yml

@@ -1,7 +1,7 @@
 jobs:
   - template: default.yml@templates
     parameters:
-      minrust: 1.42
+      minrust: 1.54
       codecov_token: $(CODECOV_TOKEN_SECRET)
 
 resources:

examples/psql_as_mysql.rs

@@ -21,11 +21,9 @@ fn main() {
 
     let jh = thread::spawn(move || {
         if let Ok((s, _)) = listener.accept() {
-            let conn = postgres::Connection::connect(
-                "postgresql://postgres@localhost:5432",
-                postgres::TlsMode::None,
-            )
-            .unwrap();
+            let conn =
+                postgres::Client::connect("postgresql://postgres@localhost:5432", postgres::NoTls)
+                    .unwrap();
             MysqlIntermediary::run_on_tcp(Postgres::new(conn), s).unwrap();
         }
     });
@@ -91,28 +89,46 @@ fn main() {
 
 // this is where the proxy server implementation starts
 
-struct Prepared<'a> {
-    stmt: postgres::stmt::Statement<'a>,
+struct Prepared {
+    stmt: postgres::Statement,
     params: Vec<Column>,
 }
 
 struct Postgres {
-    connection: postgres::Connection,
+    connection: postgres::Client,
     // NOTE: not *actually* static, but tied to our connection's lifetime.
-    prepared: Slab<Prepared<'static>>,
+    prepared: Slab<Prepared>,
 }
 
 impl Postgres {
-    fn new(c: postgres::Connection) -> Self {
+    fn new(c: postgres::Client) -> Self {
         Postgres {
             connection: c,
             prepared: Slab::new(),
         }
     }
 }
 
+#[derive(Debug)]
+enum Error {
+    Pg(postgres::Error),
+    Io(io::Error),
+}
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Self {
+        Error::Io(e)
+    }
+}
+
+impl From<postgres::Error> for Error {
+    fn from(e: postgres::Error) -> Self {
+        Error::Pg(e)
+    }
+}
+
 impl<W: io::Write> MysqlShim<W> for Postgres {
-    type Error = postgres::Error;
+    type Error = Error;
 
     fn on_prepare(&mut self, query: &str, info: StatementMetaWriter<W>) -> Result<(), Self::Error> {
         match self.connection.prepare(query) {
@@ -122,7 +138,7 @@ impl<W: io::Write> MysqlShim<W> for Postgres {
                 // client, which requires translating between psql and mysql types.
                 use std::mem;
                 let params: Vec<_> = stmt
-                    .param_types()
+                    .params()
                     .into_iter()
                     .map(|t| {
                         let ct = p2mt(t);
@@ -165,13 +181,14 @@ impl<W: io::Write> MysqlShim<W> for Postgres {
                 info.reply(id as u32, &stmt.params, &columns)?;
                 Ok(())
             }
+
             Err(e) => {
-                if let Some(db) = e.as_db() {
-                    info.error(ErrorKind::ER_NO, db.message.as_bytes())?;
+                if let Some(db) = e.as_db_error() {
+                    info.error(ErrorKind::ER_NO, db.message().as_bytes())?;
                     return Ok(());
                 }
 
-                Err(e)
+                Err(e.into())
             }
         }
     }
@@ -190,7 +207,7 @@ impl<W: io::Write> MysqlShim<W> for Postgres {
                 // we can only do that by first boxing all the values (so they can be kept in a
                 // single vec), and then collecting a *second* vec with references to those, and
                 // *then* take a slice of that vec.
-                let args: Vec<Box<dyn postgres::types::ToSql>> = ps
+                let args: Vec<Box<dyn postgres::types::ToSql + Sync>> = ps
                     .into_iter()
                     .map(|p| match p.coltype {
                         ColumnType::MYSQL_TYPE_SHORT => {
@@ -222,7 +239,7 @@ impl<W: io::Write> MysqlShim<W> for Postgres {
 
                 // lazy_query unfortunately gets us into all sorts of lifetime trouble it seems...
                 // so we do it eagerly instead.
-                answer_rows(results, stmt.query(&args[..]))
+                answer_rows(results, self.connection.query(stmt, &args[..]))
             }
         }
     }
@@ -247,49 +264,59 @@ impl Drop for Postgres {
 /// Take a set of rows from PostgreSQL and re-encode them as MySQL rows
 fn answer_rows<W: io::Write>(
     results: QueryResultWriter<W>,
-    rows: postgres::Result<postgres::rows::Rows>,
-) -> Result<(), postgres::Error> {
+    rows: Result<Vec<postgres::Row>, postgres::Error>,
+) -> Result<(), Error> {
     match rows {
         Ok(rows) => {
-            let cols: Vec<_> = rows
-                .columns()
-                .into_iter()
-                .map(|c| {
-                    let t = c.type_();
-                    let ct = p2mt(t);
-                    Column {
-                        table: t.schema().to_owned(),
-                        column: c.name().to_owned(),
-                        coltype: ct,
-                        colflags: ColumnFlags::empty(),
-                    }
-                })
-                .collect();
-
-            let mut writer = results.start(&cols)?;
-            for row in &rows {
-                for (c, col) in cols.iter().enumerate() {
-                    match col.coltype {
-                        ColumnType::MYSQL_TYPE_SHORT => writer.write_col(row.get::<_, i16>(c))?,
-                        ColumnType::MYSQL_TYPE_LONG => writer.write_col(row.get::<_, i32>(c))?,
-                        ColumnType::MYSQL_TYPE_LONGLONG => {
-                            writer.write_col(row.get::<_, i64>(c))?
-                        }
-                        ColumnType::MYSQL_TYPE_FLOAT => writer.write_col(row.get::<_, f32>(c))?,
-                        ColumnType::MYSQL_TYPE_DOUBLE => writer.write_col(row.get::<_, f64>(c))?,
-                        ColumnType::MYSQL_TYPE_STRING => {
-                            writer.write_col(row.get::<_, String>(c))?
+            if let Some(first) = rows.iter().next() {
+                let cols: Vec<_> = first
+                    .columns()
+                    .into_iter()
+                    .map(|c| {
+                        let t = c.type_();
+                        let ct = p2mt(t);
+                        Column {
+                            table: t.schema().to_owned(),
+                            column: c.name().to_owned(),
+                            coltype: ct,
+                            colflags: ColumnFlags::empty(),
                         }
-                        ct => unimplemented!(
-                            "don't know how to translate PostgreSQL \
+                    })
+                    .collect();
+
+                let mut writer = results.start(&cols)?;
+                for row in &rows {
+                    for (c, col) in cols.iter().enumerate() {
+                        match col.coltype {
+                            ColumnType::MYSQL_TYPE_SHORT => {
+                                writer.write_col(row.get::<_, i16>(c))?
+                            }
+                            ColumnType::MYSQL_TYPE_LONG => {
+                                writer.write_col(row.get::<_, i32>(c))?
+                            }
+                            ColumnType::MYSQL_TYPE_LONGLONG => {
+                                writer.write_col(row.get::<_, i64>(c))?
+                            }
+                            ColumnType::MYSQL_TYPE_FLOAT => {
+                                writer.write_col(row.get::<_, f32>(c))?
+                            }
+                            ColumnType::MYSQL_TYPE_DOUBLE => {
+                                writer.write_col(row.get::<_, f64>(c))?
+                            }
+                            ColumnType::MYSQL_TYPE_STRING => {
+                                writer.write_col(row.get::<_, String>(c))?
+                            }
+                            ct => unimplemented!(
+                                "don't know how to translate PostgreSQL \
                              argument type {:?} into MySQL value",
-                            ct
-                        ),
+                                ct
+                            ),
+                        }
                     }
+                    writer.end_row()?;
                 }
-                writer.end_row()?;
+                writer.finish()?;
             }
-            writer.finish()?;
         }
         Err(e) => {
             results.error(ErrorKind::ER_BAD_SLAVE, format!("{:?}", e).as_bytes())?;
@@ -302,12 +329,12 @@ fn answer_rows<W: io::Write>(
 fn p2mt(t: &postgres::types::Type) -> msql_srv::ColumnType {
     if let postgres::types::Kind::Simple = *t.kind() {
         match postgres::types::Type::from_oid(t.oid()) {
-            Some(postgres::types::INT2) => msql_srv::ColumnType::MYSQL_TYPE_SHORT,
-            Some(postgres::types::INT4) => msql_srv::ColumnType::MYSQL_TYPE_LONG,
-            Some(postgres::types::INT8) => msql_srv::ColumnType::MYSQL_TYPE_LONGLONG,
-            Some(postgres::types::FLOAT4) => msql_srv::ColumnType::MYSQL_TYPE_FLOAT,
-            Some(postgres::types::FLOAT8) => msql_srv::ColumnType::MYSQL_TYPE_DOUBLE,
-            Some(postgres::types::TEXT) => msql_srv::ColumnType::MYSQL_TYPE_STRING,
+            Some(postgres::types::Type::INT2) => msql_srv::ColumnType::MYSQL_TYPE_SHORT,
+            Some(postgres::types::Type::INT4) => msql_srv::ColumnType::MYSQL_TYPE_LONG,
+            Some(postgres::types::Type::INT8) => msql_srv::ColumnType::MYSQL_TYPE_LONGLONG,
+            Some(postgres::types::Type::FLOAT4) => msql_srv::ColumnType::MYSQL_TYPE_FLOAT,
+            Some(postgres::types::Type::FLOAT8) => msql_srv::ColumnType::MYSQL_TYPE_DOUBLE,
+            Some(postgres::types::Type::TEXT) => msql_srv::ColumnType::MYSQL_TYPE_STRING,
             t => {
                 unimplemented!(
                     "don't know how to translate PostgreSQL type {:?} to a MySQL type",