From ab6ab3b2e90c25608c81f38d7913d28ecde084db Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Thu, 10 Dec 2015 17:01:19 -0500 Subject: [PATCH] Run rustfmt on named_params.rs --- src/named_params.rs | 84 +++++++++++++++++++++++++++------------------ 1 file changed, 51 insertions(+), 33 deletions(-) diff --git a/src/named_params.rs b/src/named_params.rs index eb70989..dd9cc2f 100644 --- a/src/named_params.rs +++ b/src/named_params.rs @@ -1,4 +1,4 @@ -//use std::collections::HashMap; +// use std::collections::HashMap; use std::ffi::CString; use libc::c_int; @@ -35,34 +35,41 @@ impl SqliteConnection { /// /// Will return `Err` if `sql` cannot be converted to a C-compatible string or if the /// underlying SQLite call fails. - pub fn query_named_row(&self, sql: &str, params: &[(&str, &ToSql)], f: F) -> SqliteResult - where F: FnOnce(SqliteRow) -> T { + pub fn query_named_row(&self, + sql: &str, + params: &[(&str, &ToSql)], + f: F) + -> SqliteResult + where F: FnOnce(SqliteRow) -> T + { let mut stmt = try!(self.prepare(sql)); let mut rows = try!(stmt.query_named(params)); match rows.next() { Some(row) => row.map(f), - None => Err(SqliteError{ - code: ffi::SQLITE_NOTICE, - message: "Query did not return a row".to_string(), - }) + None => { + Err(SqliteError { + code: ffi::SQLITE_NOTICE, + message: "Query did not return a row".to_string(), + }) + } } } } impl<'conn> SqliteStatement<'conn> { - /*pub fn parameter_names(&self) -> HashMap { - let n = unsafe { ffi::sqlite3_bind_parameter_count(self.stmt) }; - let mut index_by_name = HashMap::with_capacity(n as usize); - for i in 1..n+1 { - let c_name = unsafe { ffi::sqlite3_bind_parameter_name(self.stmt, i) }; - if !c_name.is_null() { - let c_slice = unsafe { CStr::from_ptr(c_name).to_bytes() }; - index_by_name.insert(str::from_utf8(c_slice).unwrap().to_string(), n); - } - } - index_by_name - }*/ + // pub fn parameter_names(&self) -> HashMap { + // let n = unsafe { ffi::sqlite3_bind_parameter_count(self.stmt) }; + // let mut index_by_name = HashMap::with_capacity(n as usize); + // for i in 1..n+1 { + // let c_name = unsafe { ffi::sqlite3_bind_parameter_name(self.stmt, i) }; + // if !c_name.is_null() { + // let c_slice = unsafe { CStr::from_ptr(c_name).to_bytes() }; + // index_by_name.insert(str::from_utf8(c_slice).unwrap().to_string(), n); + // } + // } + // index_by_name + // } /// Return the index of an SQL parameter given its name. /// @@ -71,12 +78,12 @@ impl<'conn> SqliteStatement<'conn> { /// Return None if `name` is invalid (NulError) or if no matching parameter is found. pub fn parameter_index(&self, name: &str) -> Option { unsafe { - CString::new(name).ok().and_then(|c_name| + CString::new(name).ok().and_then(|c_name| { match ffi::sqlite3_bind_parameter_index(self.stmt, c_name.as_ptr()) { 0 => None, // A zero is returned if no matching parameter is found. - n => Some(n) + n => Some(n), } - ) + }) } } @@ -126,7 +133,9 @@ impl<'conn> SqliteStatement<'conn> { /// # Failure /// /// Will return `Err` if binding parameters fails. - pub fn query_named<'a>(&'a mut self, params: &[(&str, &ToSql)]) -> SqliteResult> { + pub fn query_named<'a>(&'a mut self, + params: &[(&str, &ToSql)]) + -> SqliteResult> { self.reset_if_needed(); unsafe { @@ -139,9 +148,9 @@ impl<'conn> SqliteStatement<'conn> { unsafe fn bind_named_parameters(&mut self, params: &[(&str, &ToSql)]) -> SqliteResult<()> { for &(name, value) in params { - let i = try!(self.parameter_index(name).ok_or(SqliteError{ + let i = try!(self.parameter_index(name).ok_or(SqliteError { code: ffi::SQLITE_MISUSE, - message: format!("Invalid parameter name: {}", name) + message: format!("Invalid parameter name: {}", name), })); try!(self.conn.decode_result(value.bind_parameter(self.stmt, i))); } @@ -158,26 +167,35 @@ mod test { let db = SqliteConnection::open_in_memory().unwrap(); db.execute_batch("CREATE TABLE foo(x INTEGER)").unwrap(); - assert_eq!(db.execute_named("INSERT INTO foo(x) VALUES (:x)", &[(":x", &1i32)]).unwrap(), 1); - assert_eq!(db.execute_named("INSERT INTO foo(x) VALUES (:x)", &[(":x", &2i32)]).unwrap(), 1); + assert_eq!(db.execute_named("INSERT INTO foo(x) VALUES (:x)", &[(":x", &1i32)]).unwrap(), + 1); + assert_eq!(db.execute_named("INSERT INTO foo(x) VALUES (:x)", &[(":x", &2i32)]).unwrap(), + 1); - assert_eq!(3i32, db.query_named_row("SELECT SUM(x) FROM foo WHERE x > :x", &[(":x", &0i32)], |r| r.get(0)).unwrap()); + assert_eq!(3i32, + db.query_named_row("SELECT SUM(x) FROM foo WHERE x > :x", + &[(":x", &0i32)], + |r| r.get(0)) + .unwrap()); } - #[test] + #[test] fn test_stmt_execute_named() { let db = SqliteConnection::open_in_memory().unwrap(); - let sql = "CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL, name TEXT NOT NULL, flag INTEGER)"; + let sql = "CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL, name TEXT NOT NULL, flag \ + INTEGER)"; db.execute_batch(sql).unwrap(); - let mut stmt = db.prepare("INSERT INTO test (id, name, flag) VALUES (:id, :name, :flag)").unwrap(); + let mut stmt = db.prepare("INSERT INTO test (id, name, flag) VALUES (:id, :name, :flag)") + .unwrap(); stmt.execute_named(&[(":name", &"one")]).unwrap(); } - #[test] + #[test] fn test_query_named() { let db = SqliteConnection::open_in_memory().unwrap(); - let sql = "CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL, name TEXT NOT NULL, flag INTEGER)"; + let sql = "CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL, name TEXT NOT NULL, flag \ + INTEGER)"; db.execute_batch(sql).unwrap(); let mut stmt = db.prepare("SELECT * FROM test where name = :name").unwrap();