Add batch_execute

Author: sfackler

postgres-shared/src/error/mod.rs

@@ -1,5 +1,3 @@
-//! Error types.
-
 use fallible_iterator::FallibleIterator;
 use postgres_protocol::message::backend::ErrorFields;
 use std::error;
@@ -141,7 +139,7 @@ pub struct DbError {
 
 impl DbError {
     #[doc(hidden)]
-    pub fn new_raw(fields: &mut ErrorFields) -> io::Result<DbError> {
+    pub fn new(fields: &mut ErrorFields) -> io::Result<DbError> {
         let mut severity = None;
         let mut parsed_severity = None;
         let mut code = None;
@@ -245,22 +243,6 @@ impl DbError {
             _p: (),
         })
     }
-
-    #[doc(hidden)]
-    pub fn new_connect<T>(fields: &mut ErrorFields) -> Result<T, ConnectError> {
-        match DbError::new_raw(fields) {
-            Ok(err) => Err(ConnectError::Db(Box::new(err))),
-            Err(e) => Err(ConnectError::Io(e)),
-        }
-    }
-
-    #[doc(hidden)]
-    pub fn new<T>(fields: &mut ErrorFields) -> Result<T, Error> {
-        match DbError::new_raw(fields) {
-            Ok(err) => Err(Error::Db(Box::new(err))),
-            Err(e) => Err(Error::Io(e)),
-        }
-    }
 }
 
 // manual impl to leave out _p
@@ -299,6 +281,20 @@ impl error::Error for DbError {
     }
 }
 
+/// Represents the position of an error in a query.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum ErrorPosition {
+    /// A position in the original query.
+    Normal(u32),
+    /// A position in an internally generated query.
+    Internal {
+        /// The byte position.
+        position: u32,
+        /// A query generated by the Postgres server.
+        query: String,
+    },
+}
+
 /// Reasons a new Postgres connection could fail.
 #[derive(Debug)]
 pub enum ConnectError {
@@ -355,75 +351,3 @@ impl From<DbError> for ConnectError {
         ConnectError::Db(Box::new(err))
     }
 }
-
-/// Represents the position of an error in a query.
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub enum ErrorPosition {
-    /// A position in the original query.
-    Normal(u32),
-    /// A position in an internally generated query.
-    Internal {
-        /// The byte position.
-        position: u32,
-        /// A query generated by the Postgres server.
-        query: String,
-    },
-}
-
-/// An error encountered when communicating with the Postgres server.
-#[derive(Debug)]
-pub enum Error {
-    /// An error reported by the Postgres server.
-    Db(Box<DbError>),
-    /// An error communicating with the Postgres server.
-    Io(io::Error),
-    /// An error converting between Postgres and Rust types.
-    Conversion(Box<error::Error + Sync + Send>),
-}
-
-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::Db(ref err) => write!(fmt, ": {}", err),
-            Error::Io(ref err) => write!(fmt, ": {}", err),
-            Error::Conversion(ref err) => write!(fmt, ": {}", err),
-        }
-    }
-}
-
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        match *self {
-            Error::Db(_) => "Error reported by Postgres",
-            Error::Io(_) => "Error communicating with the server",
-            Error::Conversion(_) => "Error converting between Postgres and Rust types",
-        }
-    }
-
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            Error::Db(ref err) => Some(&**err),
-            Error::Io(ref err) => Some(err),
-            Error::Conversion(ref err) => Some(&**err),
-        }
-    }
-}
-
-impl From<DbError> for Error {
-    fn from(err: DbError) -> Error {
-        Error::Db(Box::new(err))
-    }
-}
-
-impl From<io::Error> for Error {
-    fn from(err: io::Error) -> Error {
-        Error::Io(err)
-    }
-}
-
-impl From<Error> for io::Error {
-    fn from(err: Error) -> io::Error {
-        io::Error::new(io::ErrorKind::Other, err)
-    }
-}

postgres-shared/src/lib.rs

@@ -5,5 +5,51 @@ extern crate fallible_iterator;
 extern crate phf;
 extern crate postgres_protocol;
 
+use fallible_iterator::{FallibleIterator, FromFallibleIterator};
+use std::ops::Range;
+
 pub mod error;
 pub mod params;
+
+pub struct RowData {
+    buf: Vec<u8>,
+    indices: Vec<Option<Range<usize>>>,
+}
+
+impl<'a> FromFallibleIterator<Option<&'a [u8]>> for RowData {
+    fn from_fallible_iterator<I>(mut it: I) -> Result<RowData, I::Error>
+        where I: FallibleIterator<Item = Option<&'a [u8]>>
+    {
+        let mut row = RowData {
+            buf: vec![],
+            indices: Vec::with_capacity(it.size_hint().0),
+        };
+
+        while let Some(cell) = try!(it.next()) {
+            let index = match cell {
+                Some(cell) =>  {
+                    let base = row.buf.len();
+                    row.buf.extend_from_slice(cell);
+                    Some(base..row.buf.len())
+                }
+                None => None,
+            };
+            row.indices.push(index);
+        }
+
+        Ok(row)
+    }
+}
+
+impl RowData {
+    pub fn len(&self) -> usize {
+        self.indices.len()
+    }
+
+    pub fn get(&self, index: usize) -> Option<&[u8]> {
+        match &self.indices[index] {
+            &Some(ref range) => Some(&self.buf[range.clone()]),
+            &None => None,
+        }
+    }
+}

postgres-tokio/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 authors = ["Steven Fackler <[email protected]>"]
 
 [dependencies]
+fallible-iterator = "0.1.3"
 futures = "0.1.7"
 postgres-shared = { path = "../postgres-shared" }
 postgres-protocol = "0.2"

postgres-tokio/src/error.rs

@@ -0,0 +1,50 @@
+use std::error;
+use std::io;
+use std::fmt;
+
+use Connection;
+
+#[doc(inline)]
+pub use postgres_shared::error::*;
+
+#[derive(Debug)]
+pub enum Error {
+    Io(io::Error),
+    Db(Box<DbError>, Connection),
+    Conversion(Box<error::Error + Sync + Send>, Connection),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.write_str(error::Error::description(self))?;
+        match *self {
+            Error::Db(ref err, _) => write!(fmt, ": {}", err),
+            Error::Io(ref err) => write!(fmt, ": {}", err),
+            Error::Conversion(ref err, _) => write!(fmt, ": {}", err),
+        }
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        match *self {
+            Error::Db(_, _) => "Error reported by Postgres",
+            Error::Io(_) => "Error communicating with the server",
+            Error::Conversion(_, _) => "Error converting between Postgres and Rust types",
+        }
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        match *self {
+            Error::Db(ref err, _) => Some(&**err),
+            Error::Io(ref err) => Some(err),
+            Error::Conversion(ref err, _) => Some(&**err),
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Error {
+        Error::Io(err)
+    }
+}