Merge branch 'release-v0.11.8' into release

Author: sfackler

.travis.yml

@@ -3,12 +3,13 @@ sudo: required
 rust:
 - nightly
 - beta
-- 1.6.0
+- 1.7.0
 addons:
   postgresql: 9.4
 before_script:
 - "./.travis/setup.sh"
 script:
 - cargo test
+- cargo update -p bitflags --precise 0.5.0
 - cargo test --features "uuid rustc-serialize time unix_socket serde_json chrono openssl bit-vec eui48"
 - (test $TRAVIS_RUST_VERSION != "nightly" || cargo test --features nightly)

Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "postgres"
-version = "0.11.7"
+version = "0.11.8"
 authors = ["Steven Fackler <sfackler@gmail.com>"]
 license = "MIT"
 description = "A native PostgreSQL driver"
 repository = "https://github.com/sfackler/rust-postgres"
-documentation = "https://sfackler.github.io/rust-postgres/doc/v0.11.7/postgres"
+documentation = "https://sfackler.github.io/rust-postgres/doc/v0.11.8/postgres"
 readme = "README.md"
 keywords = ["database", "postgres", "postgresql", "sql"]
 include = ["src/*", "Cargo.toml", "LICENSE", "README.md", "THIRD_PARTY"]
@@ -43,4 +43,4 @@ eui48 = { version = "0.1", optional = true }
 clippy = { version = "0.0.61", optional = true }
 
 [dev-dependencies]
-url = "0.5"
+url = "1.0"

README.md

@@ -1,7 +1,7 @@
 # Rust-Postgres
 A native PostgreSQL driver for Rust.
 
-[Documentation](https://sfackler.github.io/rust-postgres/doc/v0.11.7/postgres)
+[Documentation](https://sfackler.github.io/rust-postgres/doc/v0.11.8/postgres)
 
 [![Build Status](https://travis-ci.org/sfackler/rust-postgres.png?branch=master)](https://travis-ci.org/sfackler/rust-postgres) [![Latest Version](https://img.shields.io/crates/v/postgres.svg)](https://crates.io/crates/postgres)
 
@@ -54,7 +54,7 @@ fn main() {
 ```
 
 ## Requirements
-* **Rust** - Rust-Postgres is developed against the 1.6 release of Rust
+* **Rust** - Rust-Postgres is developed against the 1.7 release of Rust
     available on http://www.rust-lang.org. It should also compile against more
     recent releases.
 
@@ -262,6 +262,13 @@ types. The driver currently supports the following conversions:
     </tbody>
 </table>
 
+`Option<T>` implements `FromSql` where `T: FromSql` and `ToSql` where `T:
+ToSql`, and represents nullable Postgres values.
+
+`&[T]` and `Vec<T>` implement `ToSql` where `T: ToSql`, and  `Vec<T>`
+additionally implements `FromSql` where `T: FromSql`, which represent
+one-dimensional Postgres arrays.
+
 More conversions can be defined by implementing the `ToSql` and `FromSql`
 traits.
 

src/lib.rs

@@ -38,7 +38,7 @@
 //!     }
 //! }
 //! ```
-#![doc(html_root_url="https://sfackler.github.io/rust-postgres/doc/v0.11.7")]
+#![doc(html_root_url="https://sfackler.github.io/rust-postgres/doc/v0.11.8")]
 #![warn(missing_docs)]
 #![allow(unknown_lints, needless_lifetimes)] // for clippy
 #![cfg_attr(all(unix, feature = "nightly"), feature(unix_socket))]
@@ -421,6 +421,8 @@ impl InnerConnection {
             Err(Error::Io(e)) => return Err(ConnectError::Io(e)),
             // Old versions of Postgres and things like Redshift don't support enums
             Err(Error::Db(ref e)) if e.code == SqlState::UndefinedTable => {}
+            // Some Postgres-like databases are missing a pg_catalog (e.g. Cockroach)
+            Err(Error::Db(ref e)) if e.code == SqlState::InvalidCatalogName => return Ok(()),
             Err(Error::Db(e)) => return Err(ConnectError::Db(e)),
             Err(Error::Conversion(_)) => unreachable!(),
         }

src/transaction.rs

@@ -151,6 +151,7 @@ impl Config {
 pub struct Transaction<'conn> {
     conn: &'conn Connection,
     depth: u32,
+    savepoint_name: Option<String>,
     commit: Cell<bool>,
     finished: bool,
 }
@@ -177,6 +178,7 @@ impl<'conn> TransactionInternals<'conn> for Transaction<'conn> {
         Transaction {
             conn: conn,
             depth: depth,
+            savepoint_name: None,
             commit: Cell::new(false),
             finished: false,
         }
@@ -195,14 +197,17 @@ impl<'conn> Transaction<'conn> {
     fn finish_inner(&mut self) -> Result<()> {
         let mut conn = self.conn.conn.borrow_mut();
         debug_assert!(self.depth == conn.trans_depth);
-        let query = match (self.commit.get(), self.depth != 1) {
-            (false, true) => "ROLLBACK TO sp",
-            (false, false) => "ROLLBACK",
-            (true, true) => "RELEASE sp",
-            (true, false) => "COMMIT",
-        };
         conn.trans_depth -= 1;
-        conn.quick_query(query).map(|_| ())
+        match (self.commit.get(), &self.savepoint_name) {
+            (false, &Some(ref savepoint_name)) => {
+                conn.quick_query(&format!("ROLLBACK TO {}", savepoint_name))
+            }
+            (false, &None) => conn.quick_query("ROLLBACK"),
+            (true, &Some(ref savepoint_name)) => {
+                conn.quick_query(&format!("RELEASE {}", savepoint_name))
+            }
+            (true, &None) => conn.quick_query("COMMIT"),
+        }.map(|_| ())
     }
 
     /// Like `Connection::prepare`.
@@ -233,22 +238,34 @@ impl<'conn> Transaction<'conn> {
         self.conn.batch_execute(query)
     }
 
-    /// Like `Connection::transaction`.
+    /// Like `Connection::transaction`, but creates a nested transaction via
+    /// a savepoint.
     ///
     /// # Panics
     ///
     /// Panics if there is an active nested transaction.
     pub fn transaction<'a>(&'a self) -> Result<Transaction<'a>> {
+        self.savepoint("sp")
+    }
+
+    /// Like `Connection::transaction`, but creates a nested transaction via
+    /// a savepoint with the specified name.
+    ///
+    /// # Panics
+    ///
+    /// Panics if there is an active nested transaction.
+    pub fn savepoint<'a>(&'a self, name: &str) -> Result<Transaction<'a>> {
         let mut conn = self.conn.conn.borrow_mut();
         check_desync!(conn);
         assert!(conn.trans_depth == self.depth,
-                "`transaction` may only be called on the active transaction");
-        try!(conn.quick_query("SAVEPOINT sp"));
+                "`savepoint` may only be called on the active transaction");
+        try!(conn.quick_query(&format!("SAVEPOINT {}", name)));
         conn.trans_depth += 1;
         Ok(Transaction {
             conn: self.conn,
-            commit: Cell::new(false),
             depth: self.depth + 1,
+            savepoint_name: Some(name.to_owned()),
+            commit: Cell::new(false),
             finished: false,
         })
     }

src/url.rs

@@ -131,8 +131,17 @@ fn decode_inner(c: &str, full_url: bool) -> DecodeResult<String> {
                             }
                         };
 
+                        let bytes_from_hex = match Vec::<u8>::from_hex(&bytes) {
+                            Ok(b) => b,
+                            _ => {
+                                return Err("Malformed input: found '%' followed by \
+                                            invalid hex  values. Character '%' must \
+                                            escaped.".to_owned())
+                            }
+                        };
+
                         // Only decode some characters if full_url:
-                        match Vec::<u8>::from_hex(&bytes).unwrap()[0] as char {
+                        match bytes_from_hex[0] as char {
                             // gen-delims:
                             ':' |
                             '/' |

tests/test.rs

@@ -89,7 +89,7 @@ fn test_unix_connection() {
     let unix_socket_directory = unix_socket_directories.split(',').next().unwrap();
 
     let path = url::percent_encoding::utf8_percent_encode(
-        unix_socket_directory, url::percent_encoding::USERNAME_ENCODE_SET);
+        unix_socket_directory, url::percent_encoding::USERINFO_ENCODE_SET);
     let url = format!("postgres://postgres@{}", path);
     let conn = or_panic!(Connection::connect(&url[..], SslMode::None));
     assert!(conn.finish().is_ok());
@@ -202,9 +202,9 @@ fn test_nested_transactions() {
             }
 
             {
-                let trans3 = or_panic!(trans2.transaction());
-                or_panic!(trans3.execute("INSERT INTO foo (id) VALUES (6)", &[]));
-                assert!(trans3.commit().is_ok());
+                let sp = or_panic!(trans2.savepoint("custom"));
+                or_panic!(sp.execute("INSERT INTO foo (id) VALUES (6)", &[]));
+                assert!(sp.commit().is_ok());
             }
 
             assert!(trans2.commit().is_ok());
@@ -250,10 +250,10 @@ fn test_nested_transactions_finish() {
             }
 
             {
-                let trans3 = or_panic!(trans2.transaction());
-                or_panic!(trans3.execute("INSERT INTO foo (id) VALUES (6)", &[]));
-                trans3.set_commit();
-                assert!(trans3.finish().is_ok());
+                let sp = or_panic!(trans2.savepoint("custom"));
+                or_panic!(sp.execute("INSERT INTO foo (id) VALUES (6)", &[]));
+                sp.set_commit();
+                assert!(sp.finish().is_ok());
             }
 
             trans2.set_commit();
@@ -294,6 +294,15 @@ fn test_trans_with_nested_trans() {
     trans.transaction().unwrap();
 }
 
+#[test]
+#[should_panic(expected = "active transaction")]
+fn test_trans_with_savepoints() {
+    let conn = or_panic!(Connection::connect("postgres://postgres@localhost", SslMode::None));
+    let trans = or_panic!(conn.transaction());
+    let _sp = or_panic!(trans.savepoint("custom"));
+    trans.savepoint("custom2").unwrap();
+}
+
 #[test]
 fn test_stmt_execute_after_transaction() {
     let conn = or_panic!(Connection::connect("postgres://postgres@localhost", SslMode::None));
@@ -938,6 +947,11 @@ fn test_get_opt_wrong_type() {
     }
 }
 
+#[test]
+fn url_unencoded_password() {
+    assert!("postgresql://username:password%1*@localhost".into_connect_params().is_err())
+}
+
 #[test]
 fn url_encoded_password() {
     let params = "postgresql://username%7b%7c:password%7b%7c@localhost".into_connect_params().unwrap();