Merge branch 'release-v0.9.3' into release

Author: sfackler

Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "postgres"
-version = "0.9.2"
+version = "0.9.3"
 authors = ["Steven Fackler <[email protected]>"]
 license = "MIT"
 description = "A native PostgreSQL driver"
 repository = "https://github.com/sfackler/rust-postgres"
-documentation = "https://sfackler.github.io/rust-postgres/doc/v0.9.2/postgres"
+documentation = "https://sfackler.github.io/rust-postgres/doc/v0.9.3/postgres"
 readme = "README.md"
 keywords = ["database", "sql"]
 build = "build.rs"

README.md

@@ -1,7 +1,7 @@
 # Rust-Postgres
 A native PostgreSQL driver for Rust.
 
-[Documentation](https://sfackler.github.io/rust-postgres/doc/v0.9.2/postgres)
+[Documentation](https://sfackler.github.io/rust-postgres/doc/v0.9.3/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)
 
@@ -57,9 +57,9 @@ fn main() {
 ```
 
 ## Requirements
-* **Rust** - Rust-Postgres is developed against the 1.0.0 release of Rust
+* **Rust** - Rust-Postgres is developed against the 1.0 release of Rust
     available on http://www.rust-lang.org. It should also compile against more
-    recent unstable releases.
+    recent releases.
 
 * **PostgreSQL 7.4 or later** - Rust-Postgres speaks version 3 of the
     PostgreSQL protocol, which corresponds to versions 7.4 and later. If your
@@ -254,13 +254,13 @@ types. The driver currently supports the following conversions:
 More conversions can be defined by implementing the `ToSql` and `FromSql`
 traits.
 
-Support for Postgres arrays is located in the
+Support for array types is located in the
 [postgres-array](https://github.com/sfackler/rust-postgres-array) crate.
 
-Support for Postgres ranges is located in the
+Support for range types is located in the
 [postgres-range](https://github.com/sfackler/rust-postgres-range) crate.
 
-Support for Postgres large objects is located in the
+Support for the large object API is located in the
 [postgres-large-object](https://github.com/sfackler/rust-postgres-large-object) crate.
 
 ## Optional features

src/error.rs

@@ -217,6 +217,9 @@ impl fmt::Display for ConnectError {
         try!(fmt.write_str(error::Error::description(self)));
         match *self {
             ConnectError::InvalidUrl(ref msg) => write!(fmt, ": {}", msg),
+            ConnectError::DbError(ref err) => write!(fmt, ": {}", err),
+            ConnectError::SslError(ref err) => write!(fmt, ": {}", err),
+            ConnectError::IoError(ref err) => write!(fmt, ": {}", err),
             _ => Ok(())
         }
     }
@@ -227,14 +230,14 @@ impl error::Error for ConnectError {
         match *self {
             ConnectError::InvalidUrl(_) => "Invalid URL",
             ConnectError::MissingUser => "User missing in URL",
-            ConnectError::DbError(_) => "An error from the Postgres server itself",
+            ConnectError::DbError(_) => "Error reported by Postgres",
             ConnectError::MissingPassword => "The server requested a password but none was provided",
             ConnectError::UnsupportedAuthentication => {
                 "The server requested an unsupported authentication method"
             }
             ConnectError::NoSslSupport => "The server does not support SSL",
             ConnectError::SslError(_) => "Error initiating SSL session",
-            ConnectError::IoError(_) => "Error communicating with server",
+            ConnectError::IoError(_) => "Error communicating with the server",
         }
     }
 
@@ -300,7 +303,10 @@ impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         try!(fmt.write_str(error::Error::description(self)));
         match *self {
+            Error::DbError(ref err) => write!(fmt, ": {}", err),
+            Error::IoError(ref err) => write!(fmt, ": {}", err),
             Error::WrongType(ref ty) => write!(fmt, ": saw type {:?}", ty),
+            Error::Conversion(ref err) => write!(fmt, ": {}", err),
             _ => Ok(()),
         }
     }
@@ -309,11 +315,11 @@ impl fmt::Display for Error {
 impl error::Error for Error {
     fn description(&self) -> &str {
         match *self {
-            Error::DbError(_) => "An error reported by the Postgres server",
-            Error::IoError(_) => "An error communicating with the Postgres server",
+            Error::DbError(_) => "Error reported by Postgres",
+            Error::IoError(_) => "Error communicating with the server",
             Error::WrongType(_) => "Unexpected type",
             Error::InvalidColumn => "Invalid column",
-            Error::Conversion(_) => "An error converting between Postgres and Rust types",
+            Error::Conversion(_) => "Error converting between Postgres and Rust types",
         }
     }
 

src/lib.rs

@@ -41,7 +41,7 @@
 //!     }
 //! }
 //! ```
-#![doc(html_root_url="https://sfackler.github.io/rust-postgres/doc/v0.9.2")]
+#![doc(html_root_url="https://sfackler.github.io/rust-postgres/doc/v0.9.3")]
 #![warn(missing_docs)]
 
 extern crate bufstream;
@@ -73,7 +73,7 @@ use std::path::PathBuf;
 use error::{Error, ConnectError, SqlState, DbError};
 use types::{ToSql, FromSql};
 use io::{StreamWrapper, NegotiateSsl};
-use types::{IsNull, Kind, Type, SessionInfo, Oid, Other};
+use types::{IsNull, Kind, Type, SessionInfo, Oid, Other, ReadWithInfo};
 use message::BackendMessage::*;
 use message::FrontendMessage::*;
 use message::{FrontendMessage, BackendMessage, RowDescriptionEntry};
@@ -1530,12 +1530,13 @@ impl<'conn> Statement<'conn> {
     /// Executes a `COPY FROM STDIN` statement, returning the number of rows
     /// added.
     ///
-    /// The contents of the provided `Read`er are passed to the Postgres server
-    /// verbatim; it is the caller's responsibility to ensure the data is in
-    /// the proper format. See the [Postgres documentation](http://www.postgresql.org/docs/9.4/static/sql-copy.html)
+    /// The contents of the provided reader are passed to the Postgres server
+    /// verbatim; it is the caller's responsibility to ensure it uses the
+    /// proper format. See the
+    /// [Postgres documentation](http://www.postgresql.org/docs/9.4/static/sql-copy.html)
     /// for details.
     ///
-    /// If the statement is not a `COPY FROM STDIN` statement, it will still be
+    /// If the statement is not a `COPY FROM STDIN` statement it will still be
     /// executed and this method will return an error.
     ///
     /// # Examples
@@ -1547,7 +1548,7 @@ impl<'conn> Statement<'conn> {
     /// let stmt = conn.prepare("COPY people FROM STDIN").unwrap();
     /// stmt.copy_in(&[], &mut "1\tjohn\n2\tjane\n".as_bytes()).unwrap();
     /// ```
-    pub fn copy_in<R: Read>(&self, params: &[&ToSql], r: &mut R) -> Result<u64> {
+    pub fn copy_in<R: ReadWithInfo>(&self, params: &[&ToSql], r: &mut R) -> Result<u64> {
         try!(self.inner_execute("", 0, params));
         let mut conn = self.conn.conn.borrow_mut();
 
@@ -1567,16 +1568,15 @@ impl<'conn> Statement<'conn> {
             }
         }
 
-        let mut buf = vec![];
+        let mut buf = [0; 16 * 1024];
         loop {
-            match r.take(16 * 1024).read_to_end(&mut buf) {
+            match fill_copy_buf(&mut buf, r, &SessionInfo::new(&conn)) {
                 Ok(0) => break,
-                Ok(_) => {
+                Ok(len) => {
                     try_desync!(conn, conn.stream.write_message(
                         &CopyData {
-                            data: &buf,
+                            data: &buf[..len],
                         }));
-                    buf.clear();
                 }
                 Err(err) => {
                     try!(conn.write_messages(&[
@@ -1628,6 +1628,20 @@ impl<'conn> Statement<'conn> {
     }
 }
 
+fn fill_copy_buf<R: ReadWithInfo>(buf: &mut [u8], r: &mut R, info: &SessionInfo)
+                                  -> std_io::Result<usize> {
+    let mut nread = 0;
+    while nread < buf.len() {
+        match r.read_with_info(&mut buf[nread..], info) {
+            Ok(0) => break,
+            Ok(n) => nread += n,
+            Err(ref e) if e.kind() == std_io::ErrorKind::Interrupted => {}
+            Err(e) => return Err(e),
+        }
+    }
+    Ok(nread)
+}
+
 /// Information about a column of the result of a query.
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct Column {

src/priv_io.rs

@@ -112,8 +112,7 @@ fn open_socket(params: &ConnectParams) -> Result<InternalStream, ConnectError> {
         }
         #[cfg(feature = "unix_socket")]
         ConnectTarget::Unix(ref path) => {
-            let mut path = path.clone();
-            path.push(&format!(".s.PGSQL.{}", port));
+            let path = path.join(&format!(".s.PGSQL.{}", port));
             Ok(try!(UnixStream::connect(&path).map(InternalStream::Unix)))
         }
     }

src/types/mod.rs

@@ -4,6 +4,7 @@ use std::collections::HashMap;
 use std::error;
 use std::fmt;
 use std::io::prelude::*;
+use std::io;
 use byteorder::{ReadBytesExt, WriteBytesExt, BigEndian};
 
 pub use self::slice::Slice;
@@ -75,6 +76,20 @@ impl<'a> SessionInfo<'a> {
     }
 }
 
+/// Like `Read` except that a `SessionInfo` object is provided as well.
+///
+/// All types that implement `Read` also implement this trait.
+pub trait ReadWithInfo {
+    /// Like `Read::read`.
+    fn read_with_info(&mut self, buf: &mut [u8], info: &SessionInfo) -> io::Result<usize>;
+}
+
+impl<R: Read> ReadWithInfo for R {
+    fn read_with_info(&mut self, buf: &mut [u8], _: &SessionInfo) -> io::Result<usize> {
+        self.read(buf)
+    }
+}
+
 /// A Postgres OID.
 pub type Oid = u32;