Add a batch_execute method

Author: sfackler

src/lib.rs

@@ -868,6 +868,51 @@ impl PostgresConnection {
         self.prepare(query).and_then(|stmt| stmt.execute(params))
     }
 
+    /// Execute a sequence of SQL statements.
+    ///
+    /// Statements should be separated by `;` characters. If an error occurs,
+    /// execution of the sequence will stop at that point. This is intended for
+    /// execution of batches of non-dynamic statements - for example, creation
+    /// of a schema for a fresh database.
+    ///
+    /// # Warning
+    ///
+    /// Prepared statements should be used for any SQL statement which contains
+    /// user-specified data, as it provides functionality to safely embed that
+    /// data in the statment. Do not form statements via string concatenation
+    /// and feed them into this method.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use postgres::{PostgresConnection, PostgresResult};
+    ///
+    /// fn init_db(conn: &PostgresConnection) -> PostgresResult<()> {
+    ///     static INIT_DB: &'static str = "
+    ///         CREATE TABLE person (
+    ///             id SERIAL PRIMARY KEY,
+    ///             name NOT NULL
+    ///         );
+    ///
+    ///         CREATE TABLE purchase (
+    ///             id SERIAL PRIMARY KEY,
+    ///             person INT NOT NULL REFERENCES person (id),
+    ///             time TIMESTAMPTZ NOT NULL,
+    ///         );
+    ///
+    ///         CREATE INDEX ON purchase (time);
+    ///         ";
+    ///     conn.batch_execute(INIT_DB)
+    /// }
+    /// ```
+    pub fn batch_execute(&self, query: &str) -> PostgresResult<()> {
+        let mut conn = self.conn.borrow_mut();
+        if conn.trans_depth != 0 {
+            return Err(PgWrongTransaction);
+        }
+        conn.quick_query(query).map(|_| ())
+    }
+
     /// Returns information used to cancel pending queries.
     ///
     /// Used with the `cancel_query` function. The object returned can be used
@@ -976,6 +1021,14 @@ impl<'conn> PostgresTransaction<'conn> {
         self.prepare(query).and_then(|s| s.execute(params))
     }
 
+    /// Like `PostgresConnection::batch_execute`.
+    pub fn batch_execute(&self, query: &str) -> PostgresResult<()> {
+        if self.conn.conn.borrow().trans_depth != self.depth {
+            return Err(PgWrongTransaction);
+        }
+        self.conn.batch_execute(query)
+    }
+
     /// Like `PostgresConnection::transaction`.
     pub fn transaction<'a>(&'a self)
             -> PostgresResult<PostgresTransaction<'a>> {

src/pool.rs

@@ -124,6 +124,11 @@ impl PooledPostgresConnection {
         self.conn.get_ref().execute(query, params)
     }
 
+    /// Like `PostgresConnection::batch_execute`.
+    pub fn batch_execute(&self, query: &str) -> PostgresResult<()> {
+        self.conn.get_ref().batch_execute(query)
+    }
+
     /// Like `PostgresConnection::transaction`.
     pub fn transaction<'a>(&'a self)
             -> PostgresResult<PostgresTransaction<'a>> {

src/test.rs

@@ -31,6 +31,7 @@ use error::{PgConnectDbError,
             SyntaxError,
             InvalidPassword,
             QueryCanceled,
+            UndefinedTable,
             InvalidCatalogName,
             PgWrongTransaction};
 use types::{ToSql, FromSql, PgInt4, PgVarchar};
@@ -339,6 +340,35 @@ fn test_stmt_finish() {
     assert!(stmt.finish().is_ok());
 }
 
+#[test]
+fn test_batch_execute() {
+    let conn = or_fail!(PostgresConnection::connect("postgres://postgres@localhost", &NoSsl));
+    let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY);
+                 INSERT INTO foo (id) VALUES (10);";
+    or_fail!(conn.batch_execute(query));
+
+    let stmt = or_fail!(conn.prepare("SELECT * from foo ORDER BY id"));
+    let result = or_fail!(stmt.query([]));
+
+    assert_eq!(vec![10i64], result.map(|row| row[1]).collect());
+}
+
+#[test]
+fn test_batch_execute_error() {
+    let conn = or_fail!(PostgresConnection::connect("postgres://postgres@localhost", &NoSsl));
+    let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY);
+                 INSERT INTO foo (id) VALUES (10);
+                 asdfa;
+                 INSERT INTO foo (id) VALUES (11)";
+    conn.batch_execute(query).unwrap_err();
+
+    match conn.prepare("SELECT * from foo ORDER BY id") {
+        Err(PgDbError(PostgresDbError { code: UndefinedTable, .. })) => {},
+        Err(e) => fail!("unexpected error {}", e),
+        _ => fail!("unexpected success"),
+    }
+}
+
 #[test]
 fn test_query() {
     let conn = or_fail!(PostgresConnection::connect("postgres://postgres@localhost", &NoSsl));