ISAR/rusqlite
3
0
Fork 0
mirror of https://github.com/isar/rusqlite.git synced 2025-01-20 07:10:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Run rustfmt on named_params.rs

Browse Source
This commit is contained in:
John Gallagher 2015-12-10 17:01:19 -05:00
parent 53979407c5
commit ab6ab3b2e9
1 changed files with 51 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
src/named_params.rs
View File

@ -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<T, F>(&self, sql: &str, params: &[(&str, &ToSql)], f: F) -> SqliteResult<T>
where F: FnOnce(SqliteRow) -> T {
pub fn query_named_row<T, F>(&self,
sql: &str,
params: &[(&str, &ToSql)],
f: F)
-> SqliteResult<T>
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<String, i32> {
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<String, i32> {
// 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<i32> {
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<SqliteRows<'a>> {
pub fn query_named<'a>(&'a mut self,
params: &[(&str, &ToSql)])
-> SqliteResult<SqliteRows<'a>> {
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();