dnim/rust-postgres
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Change negotiate_ssl back to taking &self

Browse Source 
It's not clear that &mut is necessary and it makes connection calls a
bit nicer looking.
This commit is contained in:
Steven Fackler 2015-05-13 15:17:37 -07:00
parent f957f10b19
commit 26e55ff2bc
7 changed files with 97 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/io/mod.rs
View File

@ -23,6 +23,5 @@ pub trait NegotiateSsl {
/// ///
/// The host portion of the connection parameters is provided for hostname /// The host portion of the connection parameters is provided for hostname
/// verification. /// verification.
fn negotiate_ssl(&mut self, host: &str, stream: Stream) fn negotiate_ssl(&self, host: &str, stream: Stream) -> Result<Box<StreamWrapper>, Box<Error>>;
-> Result<Box<StreamWrapper>, Box<Error>>;
} }

3
src/io/openssl.rs
View File

@ -16,8 +16,7 @@ impl StreamWrapper for SslStream<Stream> {
} }
impl NegotiateSsl for SslContext { impl NegotiateSsl for SslContext {
fn negotiate_ssl(&mut self, _: &str, stream: Stream) fn negotiate_ssl(&self, _: &str, stream: Stream) -> Result<Box<StreamWrapper>, Box<Error>> {
-> Result<Box<StreamWrapper>, Box<Error>> {
let stream = try!(SslStream::new(self, stream)); let stream = try!(SslStream::new(self, stream));
Ok(Box::new(stream)) Ok(Box::new(stream))
} }

30
src/lib.rs
View File

@ -15,7 +15,7 @@
//! } //! }
//! //!
//! fn main() { //! fn main() {
//! let conn = Connection::connect("postgresql://postgres@localhost", &mut SslMode::None) //! let conn = Connection::connect("postgresql://postgres@localhost", &SslMode::None)
//! .unwrap(); //! .unwrap();
//! //!
//! conn.execute("CREATE TABLE person ( //! conn.execute("CREATE TABLE person (
@ -379,15 +379,15 @@ pub struct CancelData {
/// # use postgres::{Connection, SslMode}; /// # use postgres::{Connection, SslMode};
/// # use std::thread; /// # use std::thread;
/// # let url = ""; /// # let url = "";
/// let conn = Connection::connect(url, &mut SslMode::None).unwrap(); /// let conn = Connection::connect(url, &SslMode::None).unwrap();
/// let cancel_data = conn.cancel_data(); /// let cancel_data = conn.cancel_data();
/// thread::spawn(move || { /// thread::spawn(move || {
/// conn.execute("SOME EXPENSIVE QUERY", &[]).unwrap(); /// conn.execute("SOME EXPENSIVE QUERY", &[]).unwrap();
/// }); /// });
/// # let _ = /// # let _ =
/// postgres::cancel_query(url, &mut SslMode::None, cancel_data); /// postgres::cancel_query(url, &SslMode::None, cancel_data);
/// ``` /// ```
pub fn cancel_query<T>(params: T, ssl: &mut SslMode, data: CancelData) pub fn cancel_query<T>(params: T, ssl: &SslMode, data: CancelData)
-> result::Result<(), ConnectError> -> result::Result<(), ConnectError>
where T: IntoConnectParams { where T: IntoConnectParams {
let params = try!(params.into_connect_params()); let params = try!(params.into_connect_params());
@ -497,7 +497,7 @@ impl Drop for InnerConnection {
} }
impl InnerConnection { impl InnerConnection {
fn connect<T>(params: T, ssl: &mut SslMode) -> result::Result<InnerConnection, ConnectError> fn connect<T>(params: T, ssl: &SslMode) -> result::Result<InnerConnection, ConnectError>
where T: IntoConnectParams { where T: IntoConnectParams {
let params = try!(params.into_connect_params()); let params = try!(params.into_connect_params());
let stream = try!(priv_io::initialize_stream(&params, ssl)); let stream = try!(priv_io::initialize_stream(&params, ssl));
@ -986,7 +986,7 @@ impl Connection {
/// # use postgres::{Connection, SslMode, ConnectError}; /// # use postgres::{Connection, SslMode, ConnectError};
/// # fn f() -> Result<(), ConnectError> { /// # fn f() -> Result<(), ConnectError> {
/// let url = "postgresql://postgres:hunter2@localhost:2994/foodb"; /// let url = "postgresql://postgres:hunter2@localhost:2994/foodb";
/// let conn = try!(Connection::connect(url, &mut SslMode::None)); /// let conn = try!(Connection::connect(url, &SslMode::None));
/// # Ok(()) }; /// # Ok(()) };
/// ``` /// ```
/// ///
@ -994,7 +994,7 @@ impl Connection {
/// # use postgres::{Connection, SslMode, ConnectError}; /// # use postgres::{Connection, SslMode, ConnectError};
/// # fn f() -> Result<(), ConnectError> { /// # fn f() -> Result<(), ConnectError> {
/// let url = "postgresql://postgres@%2Frun%2Fpostgres"; /// let url = "postgresql://postgres@%2Frun%2Fpostgres";
/// let conn = try!(Connection::connect(url, &mut SslMode::None)); /// let conn = try!(Connection::connect(url, &SslMode::None));
/// # Ok(()) }; /// # Ok(()) };
/// ``` /// ```
/// ///
@ -1014,10 +1014,10 @@ impl Connection {
/// database: None, /// database: None,
/// options: vec![], /// options: vec![],
/// }; /// };
/// let conn = try!(Connection::connect(params, &mut SslMode::None)); /// let conn = try!(Connection::connect(params, &SslMode::None));
/// # Ok(()) }; /// # Ok(()) };
/// ``` /// ```
pub fn connect<T>(params: T, ssl: &mut SslMode) -> result::Result<Connection, ConnectError> pub fn connect<T>(params: T, ssl: &SslMode) -> result::Result<Connection, ConnectError>
where T: IntoConnectParams { where T: IntoConnectParams {
InnerConnection::connect(params, ssl).map(|conn| { InnerConnection::connect(params, ssl).map(|conn| {
Connection { conn: RefCell::new(conn) } Connection { conn: RefCell::new(conn) }
@ -1049,7 +1049,7 @@ impl Connection {
/// ///
/// ```rust,no_run /// ```rust,no_run
/// # use postgres::{Connection, SslMode}; /// # use postgres::{Connection, SslMode};
/// # let conn = Connection::connect("", &mut SslMode::None).unwrap(); /// # let conn = Connection::connect("", &SslMode::None).unwrap();
/// let maybe_stmt = conn.prepare("SELECT foo FROM bar WHERE baz = $1"); /// let maybe_stmt = conn.prepare("SELECT foo FROM bar WHERE baz = $1");
/// let stmt = match maybe_stmt { /// let stmt = match maybe_stmt {
/// Ok(stmt) => stmt, /// Ok(stmt) => stmt,
@ -1072,7 +1072,7 @@ impl Connection {
/// # use postgres::{Connection, SslMode}; /// # use postgres::{Connection, SslMode};
/// # fn f() -> postgres::Result<()> { /// # fn f() -> postgres::Result<()> {
/// # let x = 10i32; /// # let x = 10i32;
/// # let conn = Connection::connect("", &mut SslMode::None).unwrap(); /// # let conn = Connection::connect("", &SslMode::None).unwrap();
/// let stmt = try!(conn.prepare_cached("SELECT foo FROM bar WHERE baz = $1")); /// let stmt = try!(conn.prepare_cached("SELECT foo FROM bar WHERE baz = $1"));
/// for row in try!(stmt.query(&[&x])) { /// for row in try!(stmt.query(&[&x])) {
/// println!("foo: {}", row.get::<_, String>(0)); /// println!("foo: {}", row.get::<_, String>(0));
@ -1111,7 +1111,7 @@ impl Connection {
/// ```rust,no_run /// ```rust,no_run
/// # use postgres::{Connection, SslMode}; /// # use postgres::{Connection, SslMode};
/// # fn foo() -> Result<(), postgres::Error> { /// # fn foo() -> Result<(), postgres::Error> {
/// # let conn = Connection::connect("", &mut SslMode::None).unwrap(); /// # let conn = Connection::connect("", &SslMode::None).unwrap();
/// let trans = try!(conn.transaction()); /// let trans = try!(conn.transaction());
/// try!(trans.execute("UPDATE foo SET bar = 10", &[])); /// try!(trans.execute("UPDATE foo SET bar = 10", &[]));
/// // ... /// // ...
@ -1499,7 +1499,7 @@ impl<'conn> Statement<'conn> {
/// ///
/// ```rust,no_run /// ```rust,no_run
/// # use postgres::{Connection, SslMode}; /// # use postgres::{Connection, SslMode};
/// # let conn = Connection::connect("", &mut SslMode::None).unwrap(); /// # let conn = Connection::connect("", &SslMode::None).unwrap();
/// # let bar = 1i32; /// # let bar = 1i32;
/// # let baz = true; /// # let baz = true;
/// let stmt = conn.prepare("UPDATE foo SET bar = $1 WHERE baz = $2").unwrap(); /// let stmt = conn.prepare("UPDATE foo SET bar = $1 WHERE baz = $2").unwrap();
@ -1558,7 +1558,7 @@ impl<'conn> Statement<'conn> {
/// ///
/// ```rust,no_run /// ```rust,no_run
/// # use postgres::{Connection, SslMode}; /// # use postgres::{Connection, SslMode};
/// # let conn = Connection::connect("", &mut SslMode::None).unwrap(); /// # let conn = Connection::connect("", &SslMode::None).unwrap();
/// let stmt = conn.prepare("SELECT foo FROM bar WHERE baz = $1").unwrap(); /// let stmt = conn.prepare("SELECT foo FROM bar WHERE baz = $1").unwrap();
/// # let baz = true; /// # let baz = true;
/// let rows = match stmt.query(&[&baz]) { /// let rows = match stmt.query(&[&baz]) {
@ -1872,7 +1872,7 @@ impl<'a> Row<'a> {
/// ///
/// ```rust,no_run /// ```rust,no_run
/// # use postgres::{Connection, SslMode}; /// # use postgres::{Connection, SslMode};
/// # let conn = Connection::connect("", &mut SslMode::None).unwrap(); /// # let conn = Connection::connect("", &SslMode::None).unwrap();
/// # let stmt = conn.prepare("").unwrap(); /// # let stmt = conn.prepare("").unwrap();
/// # let mut result = stmt.query(&[]).unwrap(); /// # let mut result = stmt.query(&[]).unwrap();
/// # let row = result.iter().next().unwrap(); /// # let row = result.iter().next().unwrap();

6
src/priv_io.rs
View File

@ -118,14 +118,14 @@ fn open_socket(params: &ConnectParams) -> Result<InternalStream, ConnectError> {
} }
} }
pub fn initialize_stream(params: &ConnectParams, ssl: &mut SslMode) pub fn initialize_stream(params: &ConnectParams, ssl: &SslMode)
-> Result<Box<StreamWrapper>, ConnectError> { -> Result<Box<StreamWrapper>, ConnectError> {
let mut socket = Stream(try!(open_socket(params))); let mut socket = Stream(try!(open_socket(params)));
let (ssl_required, negotiator) = match *ssl { let (ssl_required, negotiator) = match *ssl {
SslMode::None => return Ok(Box::new(socket)), SslMode::None => return Ok(Box::new(socket)),
SslMode::Prefer(ref mut negotiator) => (false, negotiator), SslMode::Prefer(ref negotiator) => (false, negotiator),
SslMode::Require(ref mut negotiator) => (true, negotiator), SslMode::Require(ref negotiator) => (true, negotiator),
}; };
try!(socket.write_message(&SslRequest { code: message::SSL_CODE })); try!(socket.write_message(&SslRequest { code: message::SSL_CODE }));

2
src/types/slice.rs
View File

@ -16,7 +16,7 @@ use types::IsNull;
/// ```rust,no_run /// ```rust,no_run
/// # fn foo() -> postgres::Result<()> { /// # fn foo() -> postgres::Result<()> {
/// # use postgres::{Connection, SslMode, Slice}; /// # use postgres::{Connection, SslMode, Slice};
/// # let conn = Connection::connect("", &mut SslMode::None).unwrap(); /// # let conn = Connection::connect("", &SslMode::None).unwrap();
/// let values = &[1i32, 2, 3, 4, 5, 6]; /// let values = &[1i32, 2, 3, 4, 5, 6];
/// let stmt = try!(conn.prepare("SELECT * FROM foo WHERE id = ANY($1)")); /// let stmt = try!(conn.prepare("SELECT * FROM foo WHERE id = ANY($1)"));
/// for row in &try!(stmt.query(&[&Slice(values)])) { /// for row in &try!(stmt.query(&[&Slice(values)])) {

136
tests/test.rs
View File

@ -42,17 +42,17 @@ mod types;
#[test] #[test]
fn test_non_default_database() { fn test_non_default_database() {
or_panic!(Connection::connect("postgres://postgres@localhost/postgres", &mut SslMode::None)); or_panic!(Connection::connect("postgres://postgres@localhost/postgres", &SslMode::None));
} }
#[test] #[test]
fn test_url_terminating_slash() { fn test_url_terminating_slash() {
or_panic!(Connection::connect("postgres://postgres@localhost/", &mut SslMode::None)); or_panic!(Connection::connect("postgres://postgres@localhost/", &SslMode::None));
} }
#[test] #[test]
fn test_prepare_err() { fn test_prepare_err() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let stmt = conn.prepare("invalid sql database"); let stmt = conn.prepare("invalid sql database");
match stmt { match stmt {
Err(Error::DbError(ref e)) if e.code() == &SyntaxError && e.position() == Some(&Normal(1)) => {} Err(Error::DbError(ref e)) if e.code() == &SyntaxError && e.position() == Some(&Normal(1)) => {}
@ -63,7 +63,7 @@ fn test_prepare_err() {
#[test] #[test]
fn test_unknown_database() { fn test_unknown_database() {
match Connection::connect("postgres://postgres@localhost/asdf", &mut SslMode::None) { match Connection::connect("postgres://postgres@localhost/asdf", &SslMode::None) {
Err(ConnectError::DbError(ref e)) if e.code() == &InvalidCatalogName => {} Err(ConnectError::DbError(ref e)) if e.code() == &InvalidCatalogName => {}
Err(resp) => panic!("Unexpected result {:?}", resp), Err(resp) => panic!("Unexpected result {:?}", resp),
_ => panic!("Unexpected result"), _ => panic!("Unexpected result"),
@ -72,14 +72,14 @@ fn test_unknown_database() {
#[test] #[test]
fn test_connection_finish() { fn test_connection_finish() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
assert!(conn.finish().is_ok()); assert!(conn.finish().is_ok());
} }
#[test] #[test]
#[cfg_attr(not(feature = "unix_socket"), ignore)] #[cfg_attr(not(feature = "unix_socket"), ignore)]
fn test_unix_connection() { fn test_unix_connection() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let stmt = or_panic!(conn.prepare("SHOW unix_socket_directories")); let stmt = or_panic!(conn.prepare("SHOW unix_socket_directories"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
let unix_socket_directories: String = result.iter().map(|row| row.get(0)).next().unwrap(); let unix_socket_directories: String = result.iter().map(|row| row.get(0)).next().unwrap();
@ -93,13 +93,13 @@ fn test_unix_connection() {
let path = url::percent_encoding::utf8_percent_encode( let path = url::percent_encoding::utf8_percent_encode(
unix_socket_directory, url::percent_encoding::USERNAME_ENCODE_SET); unix_socket_directory, url::percent_encoding::USERNAME_ENCODE_SET);
let url = format!("postgres://postgres@{}", path); let url = format!("postgres://postgres@{}", path);
let conn = or_panic!(Connection::connect(&url[..], &mut SslMode::None)); let conn = or_panic!(Connection::connect(&url[..], &SslMode::None));
assert!(conn.finish().is_ok()); assert!(conn.finish().is_ok());
} }
#[test] #[test]
fn test_transaction_commit() { fn test_transaction_commit() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
@ -115,7 +115,7 @@ fn test_transaction_commit() {
#[test] #[test]
fn test_transaction_commit_finish() { fn test_transaction_commit_finish() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
@ -131,7 +131,7 @@ fn test_transaction_commit_finish() {
#[test] #[test]
fn test_transaction_commit_method() { fn test_transaction_commit_method() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
@ -146,7 +146,7 @@ fn test_transaction_commit_method() {
#[test] #[test]
fn test_transaction_rollback() { fn test_transaction_rollback() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1)", &[&1i32])); or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1)", &[&1i32]));
@ -163,7 +163,7 @@ fn test_transaction_rollback() {
#[test] #[test]
fn test_transaction_rollback_finish() { fn test_transaction_rollback_finish() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1)", &[&1i32])); or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1)", &[&1i32]));
@ -180,7 +180,7 @@ fn test_transaction_rollback_finish() {
#[test] #[test]
fn test_nested_transactions() { fn test_nested_transactions() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1)", &[])); or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1)", &[]));
@ -226,7 +226,7 @@ fn test_nested_transactions() {
#[test] #[test]
fn test_nested_transactions_finish() { fn test_nested_transactions_finish() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1)", &[])); or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1)", &[]));
@ -282,7 +282,7 @@ fn test_nested_transactions_finish() {
#[test] #[test]
#[should_panic(expected = "active transaction")] #[should_panic(expected = "active transaction")]
fn test_conn_trans_when_nested() { fn test_conn_trans_when_nested() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let _trans = or_panic!(conn.transaction()); let _trans = or_panic!(conn.transaction());
conn.transaction().unwrap(); conn.transaction().unwrap();
} }
@ -290,7 +290,7 @@ fn test_conn_trans_when_nested() {
#[test] #[test]
#[should_panic(expected = "active transaction")] #[should_panic(expected = "active transaction")]
fn test_trans_with_nested_trans() { fn test_trans_with_nested_trans() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
let _trans2 = or_panic!(trans.transaction()); let _trans2 = or_panic!(trans.transaction());
trans.transaction().unwrap(); trans.transaction().unwrap();
@ -298,7 +298,7 @@ fn test_trans_with_nested_trans() {
#[test] #[test]
fn test_stmt_execute_after_transaction() { fn test_stmt_execute_after_transaction() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
let stmt = or_panic!(trans.prepare("SELECT 1")); let stmt = or_panic!(trans.prepare("SELECT 1"));
or_panic!(trans.finish()); or_panic!(trans.finish());
@ -308,7 +308,7 @@ fn test_stmt_execute_after_transaction() {
#[test] #[test]
fn test_stmt_finish() { fn test_stmt_finish() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY)", &[]));
let stmt = or_panic!(conn.prepare("SELECT * FROM foo")); let stmt = or_panic!(conn.prepare("SELECT * FROM foo"));
assert!(stmt.finish().is_ok()); assert!(stmt.finish().is_ok());
@ -316,7 +316,7 @@ fn test_stmt_finish() {
#[test] #[test]
fn test_batch_execute() { fn test_batch_execute() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY); let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY);
INSERT INTO foo (id) VALUES (10);"; INSERT INTO foo (id) VALUES (10);";
or_panic!(conn.batch_execute(query)); or_panic!(conn.batch_execute(query));
@ -329,7 +329,7 @@ fn test_batch_execute() {
#[test] #[test]
fn test_batch_execute_error() { fn test_batch_execute_error() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY); let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY);
INSERT INTO foo (id) VALUES (10); INSERT INTO foo (id) VALUES (10);
asdfa; asdfa;
@ -346,7 +346,7 @@ fn test_batch_execute_error() {
#[test] #[test]
fn test_transaction_batch_execute() { fn test_transaction_batch_execute() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY); let query = "CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY);
INSERT INTO foo (id) VALUES (10);"; INSERT INTO foo (id) VALUES (10);";
@ -360,7 +360,7 @@ fn test_transaction_batch_execute() {
#[test] #[test]
fn test_query() { fn test_query() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id BIGINT PRIMARY KEY)", &[]));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1), ($2)", or_panic!(conn.execute("INSERT INTO foo (id) VALUES ($1), ($2)",
&[&1i64, &2i64])); &[&1i64, &2i64]));
@ -372,7 +372,7 @@ fn test_query() {
#[test] #[test]
fn test_error_after_datarow() { fn test_error_after_datarow() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let stmt = or_panic!(conn.prepare(" let stmt = or_panic!(conn.prepare("
SELECT SELECT
(SELECT generate_series(1, ss.i)) (SELECT generate_series(1, ss.i))
@ -389,7 +389,7 @@ FROM (SELECT gs.i
#[test] #[test]
fn test_lazy_query() { fn test_lazy_query() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
or_panic!(trans.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[])); or_panic!(trans.execute("CREATE TEMPORARY TABLE foo (id INT PRIMARY KEY)", &[]));
@ -406,8 +406,8 @@ fn test_lazy_query() {
#[test] #[test]
#[should_panic(expected = "same `Connection` as")] #[should_panic(expected = "same `Connection` as")]
fn test_lazy_query_wrong_conn() { fn test_lazy_query_wrong_conn() {
let conn1 = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn1 = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let conn2 = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn2 = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let trans = or_panic!(conn1.transaction()); let trans = or_panic!(conn1.transaction());
let stmt = or_panic!(conn2.prepare("SELECT 1::INT")); let stmt = or_panic!(conn2.prepare("SELECT 1::INT"));
@ -416,14 +416,14 @@ fn test_lazy_query_wrong_conn() {
#[test] #[test]
fn test_param_types() { fn test_param_types() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT $1::INT, $2::VARCHAR")); let stmt = or_panic!(conn.prepare("SELECT $1::INT, $2::VARCHAR"));
assert_eq!(stmt.param_types(), &[Type::Int4, Type::Varchar][..]); assert_eq!(stmt.param_types(), &[Type::Int4, Type::Varchar][..]);
} }
#[test] #[test]
fn test_columns() { fn test_columns() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT 1::INT as a, 'hi'::VARCHAR as b")); let stmt = or_panic!(conn.prepare("SELECT 1::INT as a, 'hi'::VARCHAR as b"));
let cols = stmt.columns(); let cols = stmt.columns();
assert_eq!(2, cols.len()); assert_eq!(2, cols.len());
@ -435,7 +435,7 @@ fn test_columns() {
#[test] #[test]
fn test_execute_counts() { fn test_execute_counts() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
assert_eq!(0, or_panic!(conn.execute("CREATE TEMPORARY TABLE foo ( assert_eq!(0, or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (
id SERIAL PRIMARY KEY, id SERIAL PRIMARY KEY,
b INT b INT
@ -448,7 +448,7 @@ fn test_execute_counts() {
#[test] #[test]
fn test_wrong_param_type() { fn test_wrong_param_type() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
match conn.execute("SELECT $1::VARCHAR", &[&1i32]) { match conn.execute("SELECT $1::VARCHAR", &[&1i32]) {
Err(Error::WrongType(_)) => {} Err(Error::WrongType(_)) => {}
res => panic!("unexpected result {:?}", res) res => panic!("unexpected result {:?}", res)
@ -458,20 +458,20 @@ fn test_wrong_param_type() {
#[test] #[test]
#[should_panic(expected = "expected 2 parameters but got 1")] #[should_panic(expected = "expected 2 parameters but got 1")]
fn test_too_few_params() { fn test_too_few_params() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let _ = conn.execute("SELECT $1::INT, $2::INT", &[&1i32]); let _ = conn.execute("SELECT $1::INT, $2::INT", &[&1i32]);
} }
#[test] #[test]
#[should_panic(expected = "expected 2 parameters but got 3")] #[should_panic(expected = "expected 2 parameters but got 3")]
fn test_too_many_params() { fn test_too_many_params() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let _ = conn.execute("SELECT $1::INT, $2::INT", &[&1i32, &2i32, &3i32]); let _ = conn.execute("SELECT $1::INT, $2::INT", &[&1i32, &2i32, &3i32]);
} }
#[test] #[test]
fn test_index_named() { fn test_index_named() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT 10::INT as val")); let stmt = or_panic!(conn.prepare("SELECT 10::INT as val"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
@ -481,7 +481,7 @@ fn test_index_named() {
#[test] #[test]
#[should_panic] #[should_panic]
fn test_index_named_fail() { fn test_index_named_fail() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT 10::INT as id")); let stmt = or_panic!(conn.prepare("SELECT 10::INT as id"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
@ -490,7 +490,7 @@ fn test_index_named_fail() {
#[test] #[test]
fn test_get_named_err() { fn test_get_named_err() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT 10::INT as id")); let stmt = or_panic!(conn.prepare("SELECT 10::INT as id"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
@ -502,7 +502,7 @@ fn test_get_named_err() {
#[test] #[test]
fn test_get_was_null() { fn test_get_was_null() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT NULL::INT as id")); let stmt = or_panic!(conn.prepare("SELECT NULL::INT as id"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
@ -514,7 +514,7 @@ fn test_get_was_null() {
#[test] #[test]
fn test_get_off_by_one() { fn test_get_off_by_one() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT 10::INT as id")); let stmt = or_panic!(conn.prepare("SELECT 10::INT as id"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
@ -537,7 +537,7 @@ fn test_custom_notice_handler() {
} }
let conn = or_panic!(Connection::connect( let conn = or_panic!(Connection::connect(
"postgres://postgres@localhost?client_min_messages=NOTICE", &mut SslMode::None)); "postgres://postgres@localhost?client_min_messages=NOTICE", &SslMode::None));
conn.set_notice_handler(Box::new(Handler)); conn.set_notice_handler(Box::new(Handler));
or_panic!(conn.execute("CREATE FUNCTION pg_temp.note() RETURNS INT AS $$ or_panic!(conn.execute("CREATE FUNCTION pg_temp.note() RETURNS INT AS $$
BEGIN BEGIN
@ -551,7 +551,7 @@ fn test_custom_notice_handler() {
#[test] #[test]
fn test_notification_iterator_none() { fn test_notification_iterator_none() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
assert!(conn.notifications().next().is_none()); assert!(conn.notifications().next().is_none());
} }
@ -562,7 +562,7 @@ fn check_notification(expected: Notification, actual: Notification) {
#[test] #[test]
fn test_notification_iterator_some() { fn test_notification_iterator_some() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let mut it = conn.notifications(); let mut it = conn.notifications();
or_panic!(conn.execute("LISTEN test_notification_iterator_one_channel", &[])); or_panic!(conn.execute("LISTEN test_notification_iterator_one_channel", &[]));
or_panic!(conn.execute("LISTEN test_notification_iterator_one_channel2", &[])); or_panic!(conn.execute("LISTEN test_notification_iterator_one_channel2", &[]));
@ -592,11 +592,11 @@ fn test_notification_iterator_some() {
#[test] #[test]
fn test_notifications_next_block() { fn test_notifications_next_block() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("LISTEN test_notifications_next_block", &[])); or_panic!(conn.execute("LISTEN test_notifications_next_block", &[]));
let _t = thread::spawn(|| { let _t = thread::spawn(|| {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
thread::sleep_ms(500); thread::sleep_ms(500);
or_panic!(conn.execute("NOTIFY test_notifications_next_block, 'foo'", &[])); or_panic!(conn.execute("NOTIFY test_notifications_next_block, 'foo'", &[]));
}); });
@ -612,11 +612,11 @@ fn test_notifications_next_block() {
/* /*
#[test] #[test]
fn test_notifications_next_block_for() { fn test_notifications_next_block_for() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("LISTEN test_notifications_next_block_for", &[])); or_panic!(conn.execute("LISTEN test_notifications_next_block_for", &[]));
let _t = thread::spawn(|| { let _t = thread::spawn(|| {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
timer::sleep(Duration::milliseconds(500)); timer::sleep(Duration::milliseconds(500));
or_panic!(conn.execute("NOTIFY test_notifications_next_block_for, 'foo'", &[])); or_panic!(conn.execute("NOTIFY test_notifications_next_block_for, 'foo'", &[]));
}); });
@ -631,11 +631,11 @@ fn test_notifications_next_block_for() {
#[test] #[test]
fn test_notifications_next_block_for_timeout() { fn test_notifications_next_block_for_timeout() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("LISTEN test_notifications_next_block_for_timeout", &[])); or_panic!(conn.execute("LISTEN test_notifications_next_block_for_timeout", &[]));
let _t = thread::spawn(|| { let _t = thread::spawn(|| {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
timer::sleep(Duration::seconds(2)); timer::sleep(Duration::seconds(2));
or_panic!(conn.execute("NOTIFY test_notifications_next_block_for_timeout, 'foo'", &[])); or_panic!(conn.execute("NOTIFY test_notifications_next_block_for_timeout, 'foo'", &[]));
}); });
@ -654,12 +654,12 @@ fn test_notifications_next_block_for_timeout() {
#[test] #[test]
// This test is pretty sad, but I don't think there's a better way :( // This test is pretty sad, but I don't think there's a better way :(
fn test_cancel_query() { fn test_cancel_query() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let cancel_data = conn.cancel_data(); let cancel_data = conn.cancel_data();
let _t = thread::spawn(move || { let _t = thread::spawn(move || {
thread::sleep_ms(500); thread::sleep_ms(500);
assert!(postgres::cancel_query("postgres://postgres@localhost", &mut SslMode::None, assert!(postgres::cancel_query("postgres://postgres@localhost", &SslMode::None,
cancel_data).is_ok()); cancel_data).is_ok());
}); });
@ -690,12 +690,12 @@ fn test_prefer_ssl_conn() {
#[test] #[test]
fn test_plaintext_pass() { fn test_plaintext_pass() {
or_panic!(Connection::connect("postgres://pass_user:password@localhost/postgres", &mut SslMode::None)); or_panic!(Connection::connect("postgres://pass_user:password@localhost/postgres", &SslMode::None));
} }
#[test] #[test]
fn test_plaintext_pass_no_pass() { fn test_plaintext_pass_no_pass() {
let ret = Connection::connect("postgres://pass_user@localhost/postgres", &mut SslMode::None); let ret = Connection::connect("postgres://pass_user@localhost/postgres", &SslMode::None);
match ret { match ret {
Err(ConnectError::MissingPassword) => (), Err(ConnectError::MissingPassword) => (),
Err(err) => panic!("Unexpected error {:?}", err), Err(err) => panic!("Unexpected error {:?}", err),
@ -705,7 +705,7 @@ fn test_plaintext_pass_no_pass() {
#[test] #[test]
fn test_plaintext_pass_wrong_pass() { fn test_plaintext_pass_wrong_pass() {
let ret = Connection::connect("postgres://pass_user:asdf@localhost/postgres", &mut SslMode::None); let ret = Connection::connect("postgres://pass_user:asdf@localhost/postgres", &SslMode::None);
match ret { match ret {
Err(ConnectError::DbError(ref e)) if e.code() == &InvalidPassword => {} Err(ConnectError::DbError(ref e)) if e.code() == &InvalidPassword => {}
Err(err) => panic!("Unexpected error {:?}", err), Err(err) => panic!("Unexpected error {:?}", err),
@ -715,12 +715,12 @@ fn test_plaintext_pass_wrong_pass() {
#[test] #[test]
fn test_md5_pass() { fn test_md5_pass() {
or_panic!(Connection::connect("postgres://md5_user:password@localhost/postgres", &mut SslMode::None)); or_panic!(Connection::connect("postgres://md5_user:password@localhost/postgres", &SslMode::None));
} }
#[test] #[test]
fn test_md5_pass_no_pass() { fn test_md5_pass_no_pass() {
let ret = Connection::connect("postgres://md5_user@localhost/postgres", &mut SslMode::None); let ret = Connection::connect("postgres://md5_user@localhost/postgres", &SslMode::None);
match ret { match ret {
Err(ConnectError::MissingPassword) => (), Err(ConnectError::MissingPassword) => (),
Err(err) => panic!("Unexpected error {:?}", err), Err(err) => panic!("Unexpected error {:?}", err),
@ -730,7 +730,7 @@ fn test_md5_pass_no_pass() {
#[test] #[test]
fn test_md5_pass_wrong_pass() { fn test_md5_pass_wrong_pass() {
let ret = Connection::connect("postgres://md5_user:asdf@localhost/postgres", &mut SslMode::None); let ret = Connection::connect("postgres://md5_user:asdf@localhost/postgres", &SslMode::None);
match ret { match ret {
Err(ConnectError::DbError(ref e)) if e.code() == &InvalidPassword => {} Err(ConnectError::DbError(ref e)) if e.code() == &InvalidPassword => {}
Err(err) => panic!("Unexpected error {:?}", err), Err(err) => panic!("Unexpected error {:?}", err),
@ -740,7 +740,7 @@ fn test_md5_pass_wrong_pass() {
#[test] #[test]
fn test_execute_copy_from_err() { fn test_execute_copy_from_err() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[]));
let stmt = or_panic!(conn.prepare("COPY foo (id) FROM STDIN")); let stmt = or_panic!(conn.prepare("COPY foo (id) FROM STDIN"));
match stmt.execute(&[]) { match stmt.execute(&[]) {
@ -757,7 +757,7 @@ fn test_execute_copy_from_err() {
#[test] #[test]
fn test_copy_in() { fn test_copy_in() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)", &[]));
let stmt = or_panic!(conn.prepare_copy_in("foo", &["id", "name"])); let stmt = or_panic!(conn.prepare_copy_in("foo", &["id", "name"]));
@ -776,7 +776,7 @@ fn test_copy_in() {
#[test] #[test]
fn test_copy_in_bad_column_count() { fn test_copy_in_bad_column_count() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)", &[]));
let stmt = or_panic!(conn.prepare_copy_in("foo", &["id", "name"])); let stmt = or_panic!(conn.prepare_copy_in("foo", &["id", "name"]));
@ -813,7 +813,7 @@ fn test_copy_in_bad_column_count() {
#[test] #[test]
fn test_copy_in_bad_type() { fn test_copy_in_bad_type() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)", &[]));
let stmt = or_panic!(conn.prepare_copy_in("foo", &["id", "name"])); let stmt = or_panic!(conn.prepare_copy_in("foo", &["id", "name"]));
@ -837,7 +837,7 @@ fn test_copy_in_bad_type() {
#[test] #[test]
fn test_copy_in_weird_names() { fn test_copy_in_weird_names() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute(r#"CREATE TEMPORARY TABLE "na""me" (U&" \\\+01F4A9" VARCHAR)"#, &[])); or_panic!(conn.execute(r#"CREATE TEMPORARY TABLE "na""me" (U&" \\\+01F4A9" VARCHAR)"#, &[]));
let stmt = or_panic!(conn.prepare_copy_in("na\"me", &[" \\💩"])); let stmt = or_panic!(conn.prepare_copy_in("na\"me", &[" \\💩"]));
assert_eq!(&Type::Varchar, &stmt.column_types()[0]); assert_eq!(&Type::Varchar, &stmt.column_types()[0]);
@ -845,7 +845,7 @@ fn test_copy_in_weird_names() {
#[test] #[test]
fn test_batch_execute_copy_from_err() { fn test_batch_execute_copy_from_err() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[]));
match conn.batch_execute("COPY foo (id) FROM STDIN") { match conn.batch_execute("COPY foo (id) FROM STDIN") {
Err(Error::DbError(ref err)) if err.message().contains("COPY") => {} Err(Error::DbError(ref err)) if err.message().contains("COPY") => {}
@ -861,7 +861,7 @@ fn test_generic_connection() {
or_panic!(t.execute("SELECT 1", &[])); or_panic!(t.execute("SELECT 1", &[]));
} }
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
f(&conn); f(&conn);
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
f(&trans); f(&trans);
@ -869,7 +869,7 @@ fn test_generic_connection() {
#[test] #[test]
fn test_custom_range_element_type() { fn test_custom_range_element_type() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
or_panic!(trans.execute("CREATE TYPE floatrange AS RANGE ( or_panic!(trans.execute("CREATE TYPE floatrange AS RANGE (
subtype = float8, subtype = float8,
@ -887,7 +887,7 @@ fn test_custom_range_element_type() {
#[test] #[test]
fn test_prepare_cached() { fn test_prepare_cached() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[])); or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (id INT)", &[]));
or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1), (2)", &[])); or_panic!(conn.execute("INSERT INTO foo (id) VALUES (1), (2)", &[]));
@ -906,7 +906,7 @@ fn test_prepare_cached() {
#[test] #[test]
fn test_is_active() { fn test_is_active() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
assert!(conn.is_active()); assert!(conn.is_active());
let trans = or_panic!(conn.transaction()); let trans = or_panic!(conn.transaction());
assert!(!conn.is_active()); assert!(!conn.is_active());
@ -926,14 +926,14 @@ fn test_is_active() {
#[test] #[test]
fn test_parameter() { fn test_parameter() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
assert_eq!(Some("UTF8".to_string()), conn.parameter("client_encoding")); assert_eq!(Some("UTF8".to_string()), conn.parameter("client_encoding"));
assert_eq!(None, conn.parameter("asdf")); assert_eq!(None, conn.parameter("asdf"));
} }
#[test] #[test]
fn test_get_bytes() { fn test_get_bytes() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT '\\x00010203'::BYTEA")); let stmt = or_panic!(conn.prepare("SELECT '\\x00010203'::BYTEA"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
assert_eq!(b"\x00\x01\x02\x03", result.iter().next().unwrap().get_bytes(0).unwrap()); assert_eq!(b"\x00\x01\x02\x03", result.iter().next().unwrap().get_bytes(0).unwrap());
@ -941,7 +941,7 @@ fn test_get_bytes() {
#[test] #[test]
fn test_get_opt_wrong_type() { fn test_get_opt_wrong_type() {
let conn = Connection::connect("postgres://postgres@localhost", &mut SslMode::None).unwrap(); let conn = Connection::connect("postgres://postgres@localhost", &SslMode::None).unwrap();
let stmt = conn.prepare("SELECT 1::INT").unwrap(); let stmt = conn.prepare("SELECT 1::INT").unwrap();
let res = stmt.query(&[]).unwrap(); let res = stmt.query(&[]).unwrap();
match res.iter().next().unwrap().get_opt::<_, String>(0) { match res.iter().next().unwrap().get_opt::<_, String>(0) {
@ -960,7 +960,7 @@ fn url_encoded_password() {
#[test] #[test]
fn test_transaction_isolation_level() { fn test_transaction_isolation_level() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
assert_eq!(IsolationLevel::ReadCommitted, or_panic!(conn.transaction_isolation())); assert_eq!(IsolationLevel::ReadCommitted, or_panic!(conn.transaction_isolation()));
or_panic!(conn.set_transaction_isolation(IsolationLevel::ReadUncommitted)); or_panic!(conn.set_transaction_isolation(IsolationLevel::ReadUncommitted));
assert_eq!(IsolationLevel::ReadUncommitted, or_panic!(conn.transaction_isolation())); assert_eq!(IsolationLevel::ReadUncommitted, or_panic!(conn.transaction_isolation()));

16
tests/types/mod.rs
View File

@ -16,7 +16,7 @@ mod rustc_serialize;
mod serde; mod serde;
fn test_type<T: PartialEq+FromSql+ToSql, S: fmt::Display>(sql_type: &str, checks: &[(T, S)]) { fn test_type<T: PartialEq+FromSql+ToSql, S: fmt::Display>(sql_type: &str, checks: &[(T, S)]) {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
for &(ref val, ref repr) in checks.iter() { for &(ref val, ref repr) in checks.iter() {
let stmt = or_panic!(conn.prepare(&*format!("SELECT {}::{}", *repr, sql_type))); let stmt = or_panic!(conn.prepare(&*format!("SELECT {}::{}", *repr, sql_type)));
let result = or_panic!(stmt.query(&[])).iter().next().unwrap().get(0); let result = or_panic!(stmt.query(&[])).iter().next().unwrap().get(0);
@ -102,7 +102,7 @@ fn test_text_params() {
#[test] #[test]
fn test_bpchar_params() { fn test_bpchar_params() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo ( or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (
id SERIAL PRIMARY KEY, id SERIAL PRIMARY KEY,
b CHAR(5) b CHAR(5)
@ -118,7 +118,7 @@ fn test_bpchar_params() {
#[test] #[test]
fn test_citext_params() { fn test_citext_params() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
or_panic!(conn.execute("CREATE TEMPORARY TABLE foo ( or_panic!(conn.execute("CREATE TEMPORARY TABLE foo (
id SERIAL PRIMARY KEY, id SERIAL PRIMARY KEY,
b CITEXT b CITEXT
@ -156,7 +156,7 @@ fn test_hstore_params() {
} }
fn test_nan_param<T: PartialEq+ToSql+FromSql>(sql_type: &str) { fn test_nan_param<T: PartialEq+ToSql+FromSql>(sql_type: &str) {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let stmt = or_panic!(conn.prepare(&*format!("SELECT 'NaN'::{}", sql_type))); let stmt = or_panic!(conn.prepare(&*format!("SELECT 'NaN'::{}", sql_type)));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
let val: T = result.iter().next().unwrap().get(0); let val: T = result.iter().next().unwrap().get(0);
@ -175,7 +175,7 @@ fn test_f64_nan_param() {
#[test] #[test]
fn test_pg_database_datname() { fn test_pg_database_datname() {
let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &mut SslMode::None)); let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
let stmt = or_panic!(conn.prepare("SELECT datname FROM pg_database")); let stmt = or_panic!(conn.prepare("SELECT datname FROM pg_database"));
let result = or_panic!(stmt.query(&[])); let result = or_panic!(stmt.query(&[]));
@ -186,7 +186,7 @@ fn test_pg_database_datname() {
#[test] #[test]
fn test_slice() { fn test_slice() {
let conn = Connection::connect("postgres://postgres@localhost", &mut SslMode::None).unwrap(); let conn = Connection::connect("postgres://postgres@localhost", &SslMode::None).unwrap();
conn.batch_execute("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY, f VARCHAR); conn.batch_execute("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY, f VARCHAR);
INSERT INTO foo (f) VALUES ('a'), ('b'), ('c'), ('d');").unwrap(); INSERT INTO foo (f) VALUES ('a'), ('b'), ('c'), ('d');").unwrap();
@ -198,7 +198,7 @@ fn test_slice() {
#[test] #[test]
fn test_slice_wrong_type() { fn test_slice_wrong_type() {
let conn = Connection::connect("postgres://postgres@localhost", &mut SslMode::None).unwrap(); let conn = Connection::connect("postgres://postgres@localhost", &SslMode::None).unwrap();
conn.batch_execute("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY)").unwrap(); conn.batch_execute("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY)").unwrap();
let stmt = conn.prepare("SELECT * FROM foo WHERE id = ANY($1)").unwrap(); let stmt = conn.prepare("SELECT * FROM foo WHERE id = ANY($1)").unwrap();
@ -211,7 +211,7 @@ fn test_slice_wrong_type() {
#[test] #[test]
fn test_slice_range() { fn test_slice_range() {
let conn = Connection::connect("postgres://postgres@localhost", &mut SslMode::None).unwrap(); let conn = Connection::connect("postgres://postgres@localhost", &SslMode::None).unwrap();
let stmt = conn.prepare("SELECT $1::INT8RANGE").unwrap(); let stmt = conn.prepare("SELECT $1::INT8RANGE").unwrap();
match stmt.query(&[&Slice(&[1i64])]) { match stmt.query(&[&Slice(&[1i64])]) {