ISAR/rusqlite
3
0
Fork 0
mirror of https://github.com/isar/rusqlite.git synced 2025-05-12 01:47:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

Introduce NO_PARAMS constant

Browse Source 
As suggested here:
https://users.rust-lang.org/t/sql-parameter-values/20469/2
This commit is contained in:
gwenn 2018-09-16 11:10:19 +02:00
parent c4ae541eac
commit e7e03c3443
15 changed files with 152 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/backup.rs
View File

@ -309,8 +309,7 @@ impl<'a, 'b> Drop for Backup<'a, 'b> {
mod test {
use super::Backup;
use std::time::Duration;
use types::ToSql;
use {Connection, DatabaseName};
use {Connection, DatabaseName, NO_PARAMS};
#[test]
fn test_backup() {
@ -329,7 +328,7 @@ mod test {
}
let the_answer: i64 = dst
.query_row("SELECT x FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT x FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(42, the_answer);
@ -343,7 +342,7 @@ mod test {
}
let the_answer: i64 = dst
.query_row("SELECT SUM(x) FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT SUM(x) FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(42 + 43, the_answer);
}
@ -367,7 +366,7 @@ mod test {
}
let the_answer: i64 = dst
.query_row("SELECT x FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT x FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(42, the_answer);
@ -383,7 +382,7 @@ mod test {
}
let the_answer: i64 = dst
.query_row("SELECT SUM(x) FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT SUM(x) FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(42 + 43, the_answer);
}
@ -411,7 +410,7 @@ mod test {
}
let the_answer: i64 = dst
.query_row("SELECT x FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT x FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(42, the_answer);
@ -430,7 +429,7 @@ mod test {
}
let the_answer: i64 = dst
.query_row("SELECT SUM(x) FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT SUM(x) FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(42 + 43, the_answer);
}

5
src/blob.rs
View File

@ -18,8 +18,7 @@
//! extern crate rusqlite;
//!
//! use rusqlite::blob::ZeroBlob;
//! use rusqlite::types::ToSql;
//! use rusqlite::{Connection, DatabaseName};
//! use rusqlite::{Connection, DatabaseName, NO_PARAMS};
//! use std::io::{Read, Seek, SeekFrom, Write};
//!
//! fn main() {
@ -28,7 +27,7 @@
//! .unwrap();
//! db.execute(
//! "INSERT INTO test (content) VALUES (ZEROBLOB(10))",
//! &[] as &[&ToSql],
//! NO_PARAMS,
//! ).unwrap();
//!
//! let rowid = db.last_insert_rowid();

13
src/busy.rs
View File

@ -81,8 +81,7 @@ mod test {
use std::thread;
use std::time::Duration;
use types::ToSql;
use {Connection, Error, ErrorCode, TransactionBehavior};
use {Connection, Error, ErrorCode, TransactionBehavior, NO_PARAMS};
#[test]
fn test_default_busy() {
@ -94,11 +93,7 @@ mod test {
.transaction_with_behavior(TransactionBehavior::Exclusive)
.unwrap();
let db2 = Connection::open(&path).unwrap();
let r = db2.query_row(
"PRAGMA schema_version",
&[] as &[&ToSql],
|_| unreachable!(),
);
let r = db2.query_row("PRAGMA schema_version", NO_PARAMS, |_| unreachable!());
match r.unwrap_err() {
Error::SqliteFailure(err, _) => {
assert_eq!(err.code, ErrorCode::DatabaseBusy);
@ -130,7 +125,7 @@ mod test {
assert_eq!(tx.recv().unwrap(), 1);
let _ = db2
.query_row("PRAGMA schema_version", &[] as &[&ToSql], |row| {
.query_row("PRAGMA schema_version", NO_PARAMS, |row| {
row.get_checked::<_, i32>(0)
}).expect("unexpected error");
@ -168,7 +163,7 @@ mod test {
assert_eq!(tx.recv().unwrap(), 1);
let _ = db2
.query_row("PRAGMA schema_version", &[] as &[&ToSql], |row| {
.query_row("PRAGMA schema_version", NO_PARAMS, |row| {
row.get_checked::<_, i32>(0)
}).expect("unexpected error");
assert_eq!(CALLED.load(Ordering::Relaxed), true);

31
src/cache.rs
View File

@ -152,8 +152,7 @@ impl StatementCache {
#[cfg(test)]
mod test {
use super::StatementCache;
use types::ToSql;
use Connection;
use {Connection, NO_PARAMS};
impl StatementCache {
fn clear(&self) {
@ -183,8 +182,7 @@ mod test {
assert_eq!(0, cache.len());
assert_eq!(
0,
stmt.query_row(&[] as &[&ToSql], |r| r.get::<_, i64>(0))
.unwrap()
stmt.query_row(NO_PARAMS, |r| r.get::<_, i64>(0)).unwrap()
);
}
assert_eq!(1, cache.len());
@ -194,8 +192,7 @@ mod test {
assert_eq!(0, cache.len());
assert_eq!(
0,
stmt.query_row(&[] as &[&ToSql], |r| r.get::<_, i64>(0))
.unwrap()
stmt.query_row(NO_PARAMS, |r| r.get::<_, i64>(0)).unwrap()
);
}
assert_eq!(1, cache.len());
@ -216,8 +213,7 @@ mod test {
assert_eq!(0, cache.len());
assert_eq!(
0,
stmt.query_row(&[] as &[&ToSql], |r| r.get::<_, i64>(0))
.unwrap()
stmt.query_row(NO_PARAMS, |r| r.get::<_, i64>(0)).unwrap()
);
}
assert_eq!(1, cache.len());
@ -230,8 +226,7 @@ mod test {
assert_eq!(0, cache.len());
assert_eq!(
0,
stmt.query_row(&[] as &[&ToSql], |r| r.get::<_, i64>(0))
.unwrap()
stmt.query_row(NO_PARAMS, |r| r.get::<_, i64>(0)).unwrap()
);
}
assert_eq!(0, cache.len());
@ -242,8 +237,7 @@ mod test {
assert_eq!(0, cache.len());
assert_eq!(
0,
stmt.query_row(&[] as &[&ToSql], |r| r.get::<_, i64>(0))
.unwrap()
stmt.query_row(NO_PARAMS, |r| r.get::<_, i64>(0)).unwrap()
);
}
assert_eq!(1, cache.len());
@ -260,8 +254,7 @@ mod test {
assert_eq!(0, cache.len());
assert_eq!(
0,
stmt.query_row(&[] as &[&ToSql], |r| r.get::<_, i64>(0))
.unwrap()
stmt.query_row(NO_PARAMS, |r| r.get::<_, i64>(0)).unwrap()
);
stmt.discard();
}
@ -284,7 +277,7 @@ mod test {
let mut stmt = db.prepare_cached(sql).unwrap();
assert_eq!(
1i32,
stmt.query_map::<i32, _, _>(&[] as &[&ToSql], |r| r.get(0))
stmt.query_map::<i32, _, _>(NO_PARAMS, |r| r.get(0))
.unwrap()
.next()
.unwrap()
@ -303,7 +296,7 @@ mod test {
let mut stmt = db.prepare_cached(sql).unwrap();
assert_eq!(
(1i32, 2i32),
stmt.query_map(&[] as &[&ToSql], |r| (r.get(0), r.get(1)))
stmt.query_map(NO_PARAMS, |r| (r.get(0), r.get(1)))
.unwrap()
.next()
.unwrap()
@ -333,8 +326,7 @@ mod test {
assert_eq!(0, cache.len());
assert_eq!(
0,
stmt.query_row(&[] as &[&ToSql], |r| r.get::<_, i64>(0))
.unwrap()
stmt.query_row(NO_PARAMS, |r| r.get::<_, i64>(0)).unwrap()
);
}
assert_eq!(1, cache.len());
@ -344,8 +336,7 @@ mod test {
assert_eq!(0, cache.len());
assert_eq!(
0,
stmt.query_row(&[] as &[&ToSql], |r| r.get::<_, i64>(0))
.unwrap()
stmt.query_row(NO_PARAMS, |r| r.get::<_, i64>(0)).unwrap()
);
}
assert_eq!(1, cache.len());

61
src/functions.rs
View File

@ -14,8 +14,7 @@
//! extern crate regex;
//!
//! use regex::Regex;
//! use rusqlite::types::ToSql;
//! use rusqlite::{Connection, Error, Result};
//! use rusqlite::{Connection, Error, Result, NO_PARAMS};
//! use std::collections::HashMap;
//!
//! fn add_regexp_function(db: &Connection) -> Result<()> {
@ -46,7 +45,7 @@
//! let is_match: bool = db
//! .query_row(
//! "SELECT regexp('[aeiou]*', 'aaaaeeeiii')",
//! &[] as &[&ToSql],
//! NO_PARAMS,
//! |row| row.get(0),
//! ).unwrap();
//!
@ -212,15 +211,14 @@ impl Connection {
/// # Example
///
/// ```rust
/// # use rusqlite::types::ToSql;
/// # use rusqlite::{Connection, Result};
/// # use rusqlite::{Connection, Result, NO_PARAMS};
/// fn scalar_function_example(db: Connection) -> Result<()> {
/// try!(db.create_scalar_function("halve", 1, true, |ctx| {
/// let value = try!(ctx.get::<f64>(0));
/// Ok(value / 2f64)
/// }));
///
/// let six_halved: f64 = try!(db.query_row("SELECT halve(6)", &[] as &[&ToSql], |r| r.get(0)));
/// let six_halved: f64 = try!(db.query_row("SELECT halve(6)", NO_PARAMS, |r| r.get(0)));
/// assert_eq!(six_halved, 3f64);
/// Ok(())
/// }
@ -482,8 +480,7 @@ mod test {
use std::os::raw::c_double;
use functions::{Aggregate, Context};
use types::ToSql;
use {Connection, Error, Result};
use {Connection, Error, Result, NO_PARAMS};
fn half(ctx: &Context) -> Result<c_double> {
assert!(ctx.len() == 1, "called with unexpected number of arguments");
@ -495,7 +492,7 @@ mod test {
fn test_function_half() {
let db = Connection::open_in_memory().unwrap();
db.create_scalar_function("half", 1, true, half).unwrap();
let result: Result<f64> = db.query_row("SELECT half(6)", &[] as &[&ToSql], |r| r.get(0));
let result: Result<f64> = db.query_row("SELECT half(6)", NO_PARAMS, |r| r.get(0));
assert!((3f64 - result.unwrap()).abs() < EPSILON);
}
@ -504,11 +501,11 @@ mod test {
fn test_remove_function() {
let db = Connection::open_in_memory().unwrap();
db.create_scalar_function("half", 1, true, half).unwrap();
let result: Result<f64> = db.query_row("SELECT half(6)", &[] as &[&ToSql], |r| r.get(0));
let result: Result<f64> = db.query_row("SELECT half(6)", NO_PARAMS, |r| r.get(0));
assert!((3f64 - result.unwrap()).abs() < EPSILON);
db.remove_function("half", 1).unwrap();
let result: Result<f64> = db.query_row("SELECT half(6)", &[] as &[&ToSql], |r| r.get(0));
let result: Result<f64> = db.query_row("SELECT half(6)", NO_PARAMS, |r| r.get(0));
assert!(result.is_err());
}
@ -558,17 +555,16 @@ mod test {
db.create_scalar_function("regexp", 2, true, regexp_with_auxilliary)
.unwrap();
let result: Result<bool> = db.query_row(
"SELECT regexp('l.s[aeiouy]', 'lisa')",
&[] as &[&ToSql],
|r| r.get(0),
);
let result: Result<bool> =
db.query_row("SELECT regexp('l.s[aeiouy]', 'lisa')", NO_PARAMS, |r| {
r.get(0)
});
assert_eq!(true, result.unwrap());
let result: Result<i64> = db.query_row(
"SELECT COUNT(*) FROM foo WHERE regexp('l.s[aeiouy]', x) == 1",
&[] as &[&ToSql],
NO_PARAMS,
|r| r.get(0),
);
@ -611,17 +607,16 @@ mod test {
Ok(regex.is_match(&text))
}).unwrap();
let result: Result<bool> = db.query_row(
"SELECT regexp('l.s[aeiouy]', 'lisa')",
&[] as &[&ToSql],
|r| r.get(0),
);
let result: Result<bool> =
db.query_row("SELECT regexp('l.s[aeiouy]', 'lisa')", NO_PARAMS, |r| {
r.get(0)
});
assert_eq!(true, result.unwrap());
let result: Result<i64> = db.query_row(
"SELECT COUNT(*) FROM foo WHERE regexp('l.s[aeiouy]', x) == 1",
&[] as &[&ToSql],
NO_PARAMS,
|r| r.get(0),
);
@ -647,7 +642,7 @@ mod test {
("onetwo", "SELECT my_concat('one', 'two')"),
("abc", "SELECT my_concat('a', 'b', 'c')"),
] {
let result: String = db.query_row(query, &[] as &[&ToSql], |r| r.get(0)).unwrap();
let result: String = db.query_row(query, NO_PARAMS, |r| r.get(0)).unwrap();
assert_eq!(expected, result);
}
}
@ -693,21 +688,17 @@ mod test {
// sum should return NULL when given no columns (contrast with count below)
let no_result = "SELECT my_sum(i) FROM (SELECT 2 AS i WHERE 1 <> 1)";
let result: Option<i64> = db
.query_row(no_result, &[] as &[&ToSql], |r| r.get(0))
.unwrap();
let result: Option<i64> = db.query_row(no_result, NO_PARAMS, |r| r.get(0)).unwrap();
assert!(result.is_none());
let single_sum = "SELECT my_sum(i) FROM (SELECT 2 AS i UNION ALL SELECT 2)";
let result: i64 = db
.query_row(single_sum, &[] as &[&ToSql], |r| r.get(0))
.unwrap();
let result: i64 = db.query_row(single_sum, NO_PARAMS, |r| r.get(0)).unwrap();
assert_eq!(4, result);
let dual_sum = "SELECT my_sum(i), my_sum(j) FROM (SELECT 2 AS i, 1 AS j UNION ALL SELECT \
2, 1)";
let result: (i64, i64) = db
.query_row(dual_sum, &[] as &[&ToSql], |r| (r.get(0), r.get(1)))
.query_row(dual_sum, NO_PARAMS, |r| (r.get(0), r.get(1)))
.unwrap();
assert_eq!((4, 2), result);
}
@ -720,15 +711,11 @@ mod test {
// count should return 0 when given no columns (contrast with sum above)
let no_result = "SELECT my_count(i) FROM (SELECT 2 AS i WHERE 1 <> 1)";
let result: i64 = db
.query_row(no_result, &[] as &[&ToSql], |r| r.get(0))
.unwrap();
let result: i64 = db.query_row(no_result, NO_PARAMS, |r| r.get(0)).unwrap();
assert_eq!(result, 0);
let single_sum = "SELECT my_count(i) FROM (SELECT 2 AS i UNION ALL SELECT 2)";
let result: i64 = db
.query_row(single_sum, &[] as &[&ToSql], |r| r.get(0))
.unwrap();
let result: i64 = db.query_row(single_sum, NO_PARAMS, |r| r.get(0)).unwrap();
assert_eq!(2, result);
}
}

87
src/lib.rs
View File

@ -6,7 +6,7 @@
//! extern crate time;
//!
//! use rusqlite::types::ToSql;
//! use rusqlite::Connection;
//! use rusqlite::{Connection, NO_PARAMS};
//! use time::Timespec;
//!
//! #[derive(Debug)]
@ -27,7 +27,7 @@
//! time_created TEXT NOT NULL,
//! data BLOB
//! )",
//! &[] as &[&ToSql],
//! NO_PARAMS,
//! ).unwrap();
//! let me = Person {
//! id: 0,
@ -45,7 +45,7 @@
//! .prepare("SELECT id, name, time_created, data FROM person")
//! .unwrap();
//! let person_iter = stmt
//! .query_map(&[] as &[&ToSql], |row| Person {
//! .query_map(NO_PARAMS, |row| Person {
//! id: row.get(0),
//! name: row.get(1),
//! time_created: row.get(2),
@ -140,6 +140,8 @@ pub mod vtab;
// Number of cached prepared statements we'll hold on to.
const STATEMENT_CACHE_DEFAULT_CAPACITY: usize = 16;
/// To be used when your statement has no [parameter](https://sqlite.org/lang_expr.html#varparam).
pub const NO_PARAMS: &'static [&'static ToSql] = &[];
/// Old name for `Result`. `SqliteResult` is deprecated.
#[deprecated(since = "0.6.0", note = "Use Result instead")]
@ -367,12 +369,11 @@ impl Connection {
/// ## Example
///
/// ```rust,no_run
/// # use rusqlite::{Result,Connection};
/// # use rusqlite::types::ToSql;
/// # use rusqlite::{Result,Connection, NO_PARAMS};
/// fn preferred_locale(conn: &Connection) -> Result<String> {
/// conn.query_row(
/// "SELECT value FROM preferences WHERE name='locale'",
/// &[] as &[&ToSql],
/// NO_PARAMS,
/// |row| row.get(0),
/// )
/// }
@ -423,12 +424,11 @@ impl Connection {
/// ## Example
///
/// ```rust,no_run
/// # use rusqlite::{Result,Connection};
/// # use rusqlite::types::ToSql;
/// # use rusqlite::{Result,Connection, NO_PARAMS};
/// fn preferred_locale(conn: &Connection) -> Result<String> {
/// conn.query_row_and_then(
/// "SELECT value FROM preferences WHERE name='locale'",
/// &[] as &[&ToSql],
/// NO_PARAMS,
/// |row| row.get_checked(0),
/// )
/// }
@ -1064,10 +1064,10 @@ mod test {
// SELECT first makes sqlite lock with a shared lock
let _ = tx1
.query_row("SELECT x FROM foo LIMIT 1", &[] as &[&ToSql], |_| ())
.query_row("SELECT x FROM foo LIMIT 1", NO_PARAMS, |_| ())
.unwrap();
let _ = tx2
.query_row("SELECT x FROM foo LIMIT 1", &[] as &[&ToSql], |_| ())
.query_row("SELECT x FROM foo LIMIT 1", NO_PARAMS, |_| ())
.unwrap();
tx1.execute("INSERT INTO foo VALUES(?1)", &[1]).unwrap();
@ -1101,8 +1101,7 @@ mod test {
let path_string = path.to_str().unwrap();
let db = Connection::open(&path_string).unwrap();
let the_answer: Result<i64> =
db.query_row("SELECT x FROM foo", &[] as &[&ToSql], |r| r.get(0));
let the_answer: Result<i64> = db.query_row("SELECT x FROM foo", NO_PARAMS, |r| r.get(0));
assert_eq!(42i64, the_answer.unwrap());
}
@ -1203,7 +1202,7 @@ mod test {
assert_eq!(
3i32,
db.query_row::<i32, _, _>("SELECT SUM(x) FROM foo", &[] as &[&ToSql], |r| r.get(0))
db.query_row::<i32, _, _>("SELECT SUM(x) FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap()
);
}
@ -1302,7 +1301,7 @@ mod test {
let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
let results: Result<Vec<String>> = query
.query_map(&[] as &[&ToSql], |row| row.get(1))
.query_map(NO_PARAMS, |row| row.get(1))
.unwrap()
.collect();
@ -1323,21 +1322,18 @@ mod test {
assert_eq!(
10i64,
db.query_row::<i64, _, _>("SELECT SUM(x) FROM foo", &[] as &[&ToSql], |r| r.get(0))
db.query_row::<i64, _, _>("SELECT SUM(x) FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap()
);
let result: Result<i64> =
db.query_row("SELECT x FROM foo WHERE x > 5", &[] as &[&ToSql], |r| {
r.get(0)
});
db.query_row("SELECT x FROM foo WHERE x > 5", NO_PARAMS, |r| r.get(0));
match result.unwrap_err() {
Error::QueryReturnedNoRows => (),
err => panic!("Unexpected error {}", err),
}
let bad_query_result =
db.query_row("NOT A PROPER QUERY; test123", &[] as &[&ToSql], |_| ());
let bad_query_result = db.query_row("NOT A PROPER QUERY; test123", NO_PARAMS, |_| ());
assert!(bad_query_result.is_err());
}
@ -1348,12 +1344,12 @@ mod test {
assert_eq!(
"memory",
db.query_row::<String, _, _>("PRAGMA journal_mode", &[] as &[&ToSql], |r| r.get(0))
db.query_row::<String, _, _>("PRAGMA journal_mode", NO_PARAMS, |r| r.get(0))
.unwrap()
);
assert_eq!(
"off",
db.query_row::<String, _, _>("PRAGMA journal_mode=off", &[] as &[&ToSql], |r| r.get(0))
db.query_row::<String, _, _>("PRAGMA journal_mode=off", NO_PARAMS, |r| r.get(0))
.unwrap()
);
}
@ -1378,7 +1374,7 @@ mod test {
let mut stmt = db.prepare("INSERT INTO foo DEFAULT VALUES").unwrap();
for _ in 0i32..9 {
stmt.execute(&[] as &[&ToSql]).unwrap();
stmt.execute(NO_PARAMS).unwrap();
}
assert_eq!(db.last_insert_rowid(), 10);
}
@ -1400,7 +1396,7 @@ mod test {
let mut stmt = db.prepare("PRAGMA schema_version").unwrap();
assert!(!db.is_busy());
{
let mut rows = stmt.query(&[] as &[&ToSql]).unwrap();
let mut rows = stmt.query(NO_PARAMS).unwrap();
assert!(!db.is_busy());
let row = rows.next();
assert!(db.is_busy());
@ -1432,7 +1428,7 @@ mod test {
let db = checked_memory_handle();
db.execute_batch("CREATE TABLE foo(x NOT NULL)").unwrap();
let result = db.execute("INSERT INTO foo (x) VALUES (NULL)", &[] as &[&ToSql]);
let result = db.execute("INSERT INTO foo (x) VALUES (NULL)", NO_PARAMS);
assert!(result.is_err());
match result.unwrap_err() {
@ -1508,7 +1504,7 @@ mod test {
let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
let results: Result<Vec<String>> = query
.query_and_then(&[] as &[&ToSql], |row| row.get_checked(1))
.query_and_then(NO_PARAMS, |row| row.get_checked(1))
.unwrap()
.collect();
@ -1529,7 +1525,7 @@ mod test {
let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
let bad_type: Result<Vec<f64>> = query
.query_and_then(&[] as &[&ToSql], |row| row.get_checked(1))
.query_and_then(NO_PARAMS, |row| row.get_checked(1))
.unwrap()
.collect();
@ -1539,7 +1535,7 @@ mod test {
}
let bad_idx: Result<Vec<String>> = query
.query_and_then(&[] as &[&ToSql], |row| row.get_checked(3))
.query_and_then(NO_PARAMS, |row| row.get_checked(3))
.unwrap()
.collect();
@ -1563,7 +1559,7 @@ mod test {
let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
let results: CustomResult<Vec<String>> = query
.query_and_then(&[] as &[&ToSql], |row| {
.query_and_then(NO_PARAMS, |row| {
row.get_checked(1).map_err(CustomError::Sqlite)
}).unwrap()
.collect();
@ -1585,7 +1581,7 @@ mod test {
let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
let bad_type: CustomResult<Vec<f64>> = query
.query_and_then(&[] as &[&ToSql], |row| {
.query_and_then(NO_PARAMS, |row| {
row.get_checked(1).map_err(CustomError::Sqlite)
}).unwrap()
.collect();
@ -1596,7 +1592,7 @@ mod test {
}
let bad_idx: CustomResult<Vec<String>> = query
.query_and_then(&[] as &[&ToSql], |row| {
.query_and_then(NO_PARAMS, |row| {
row.get_checked(3).map_err(CustomError::Sqlite)
}).unwrap()
.collect();
@ -1607,7 +1603,7 @@ mod test {
}
let non_sqlite_err: CustomResult<Vec<String>> = query
.query_and_then(&[] as &[&ToSql], |_| Err(CustomError::SomeError))
.query_and_then(NO_PARAMS, |_| Err(CustomError::SomeError))
.unwrap()
.collect();
@ -1627,10 +1623,9 @@ mod test {
db.execute_batch(sql).unwrap();
let query = "SELECT x, y FROM foo ORDER BY x DESC";
let results: CustomResult<String> =
db.query_row_and_then(query, &[] as &[&ToSql], |row| {
row.get_checked(1).map_err(CustomError::Sqlite)
});
let results: CustomResult<String> = db.query_row_and_then(query, NO_PARAMS, |row| {
row.get_checked(1).map_err(CustomError::Sqlite)
});
assert_eq!(results.unwrap(), "hello");
}
@ -1645,20 +1640,18 @@ mod test {
db.execute_batch(sql).unwrap();
let query = "SELECT x, y FROM foo ORDER BY x DESC";
let bad_type: CustomResult<f64> =
db.query_row_and_then(query, &[] as &[&ToSql], |row| {
row.get_checked(1).map_err(CustomError::Sqlite)
});
let bad_type: CustomResult<f64> = db.query_row_and_then(query, NO_PARAMS, |row| {
row.get_checked(1).map_err(CustomError::Sqlite)
});
match bad_type.unwrap_err() {
CustomError::Sqlite(Error::InvalidColumnType(_, _)) => (),
err => panic!("Unexpected error {}", err),
}
let bad_idx: CustomResult<String> =
db.query_row_and_then(query, &[] as &[&ToSql], |row| {
row.get_checked(3).map_err(CustomError::Sqlite)
});
let bad_idx: CustomResult<String> = db.query_row_and_then(query, NO_PARAMS, |row| {
row.get_checked(3).map_err(CustomError::Sqlite)
});
match bad_idx.unwrap_err() {
CustomError::Sqlite(Error::InvalidColumnIndex(_)) => (),
@ -1666,7 +1659,7 @@ mod test {
}
let non_sqlite_err: CustomResult<String> =
db.query_row_and_then(query, &[] as &[&ToSql], |_| Err(CustomError::SomeError));
db.query_row_and_then(query, NO_PARAMS, |_| Err(CustomError::SomeError));
match non_sqlite_err.unwrap_err() {
CustomError::SomeError => (),
@ -1683,7 +1676,7 @@ mod test {
END;";
db.execute_batch(sql).unwrap();
db.query_row("SELECT * FROM foo", &[] as &[&ToSql], |r| {
db.query_row("SELECT * FROM foo", NO_PARAMS, |r| {
assert_eq!(2, r.column_count())
}).unwrap();
}

39
src/statement.rs
View File

@ -157,11 +157,10 @@ impl<'conn> Statement<'conn> {
/// ## Example
///
/// ```rust,no_run
/// # use rusqlite::{Connection, Result};
/// # use rusqlite::types::ToSql;
/// # use rusqlite::{Connection, Result, NO_PARAMS};
/// fn get_names(conn: &Connection) -> Result<Vec<String>> {
/// let mut stmt = try!(conn.prepare("SELECT name FROM people"));
/// let mut rows = try!(stmt.query(&[] as &[&ToSql]));
/// let mut rows = try!(stmt.query(NO_PARAMS));
///
/// let mut names = Vec::new();
/// while let Some(result_row) = rows.next() {
@ -221,11 +220,10 @@ impl<'conn> Statement<'conn> {
/// ## Example
///
/// ```rust,no_run
/// # use rusqlite::{Connection, Result};
/// # use rusqlite::types::ToSql;
/// # use rusqlite::{Connection, Result, NO_PARAMS};
/// fn get_names(conn: &Connection) -> Result<Vec<String>> {
/// let mut stmt = try!(conn.prepare("SELECT name FROM people"));
/// let rows = try!(stmt.query_map(&[] as &[&ToSql], |row| row.get(0)));
/// let rows = try!(stmt.query_map(NO_PARAMS, |row| row.get(0)));
///
/// let mut names = Vec::new();
/// for name_result in rows {
@ -675,8 +673,7 @@ impl<'conn> Statement<'conn> {
#[cfg(test)]
mod test {
use types::ToSql;
use {Connection, Error, Result};
use {Connection, Error, Result, NO_PARAMS};
#[test]
fn test_execute_named() {
@ -813,11 +810,9 @@ mod test {
stmt.execute_named(&[(":x", &"one")]).unwrap();
let result: Option<String> = db
.query_row(
"SELECT y FROM test WHERE x = 'one'",
&[] as &[&ToSql],
|row| row.get(0),
).unwrap();
.query_row("SELECT y FROM test WHERE x = 'one'", NO_PARAMS, |row| {
row.get(0)
}).unwrap();
assert!(result.is_none());
}
@ -834,11 +829,9 @@ mod test {
stmt.execute_named(&[(":y", &"two")]).unwrap();
let result: String = db
.query_row(
"SELECT x FROM test WHERE y = 'two'",
&[] as &[&ToSql],
|row| row.get(0),
).unwrap();
.query_row("SELECT x FROM test WHERE y = 'two'", NO_PARAMS, |row| {
row.get(0)
}).unwrap();
assert_eq!(result, "one");
}
@ -859,7 +852,7 @@ mod test {
let mut multi = db
.prepare("INSERT INTO foo (x) SELECT 3 UNION ALL SELECT 4")
.unwrap();
match multi.insert(&[] as &[&ToSql]).unwrap_err() {
match multi.insert(NO_PARAMS).unwrap_err() {
Error::StatementChangedRows(2) => (),
err => panic!("Unexpected error {}", err),
}
@ -879,14 +872,14 @@ mod test {
assert_eq!(
db.prepare("INSERT INTO foo VALUES (10)")
.unwrap()
.insert(&[] as &[&ToSql])
.insert(NO_PARAMS)
.unwrap(),
1
);
assert_eq!(
db.prepare("INSERT INTO bar VALUES (10)")
.unwrap()
.insert(&[] as &[&ToSql])
.insert(NO_PARAMS)
.unwrap(),
1
);
@ -930,7 +923,7 @@ mod test {
END;";
db.execute_batch(sql).unwrap();
let mut stmt = db.prepare("SELECT y FROM foo").unwrap();
let y: Result<i64> = stmt.query_row(&[] as &[&ToSql], |r| r.get("y"));
let y: Result<i64> = stmt.query_row(NO_PARAMS, |r| r.get("y"));
assert_eq!(3i64, y.unwrap());
}
@ -943,7 +936,7 @@ mod test {
END;";
db.execute_batch(sql).unwrap();
let mut stmt = db.prepare("SELECT y as Y FROM foo").unwrap();
let y: Result<i64> = stmt.query_row(&[] as &[&ToSql], |r| r.get("y"));
let y: Result<i64> = stmt.query_row(NO_PARAMS, |r| r.get("y"));
assert_eq!(3i64, y.unwrap());
}

9
src/transaction.rs
View File

@ -419,8 +419,7 @@ impl Connection {
#[cfg(test)]
mod test {
use super::DropBehavior;
use types::ToSql;
use Connection;
use {Connection, NO_PARAMS};
fn checked_memory_handle() -> Connection {
let db = Connection::open_in_memory().unwrap();
@ -445,7 +444,7 @@ mod test {
let tx = db.transaction().unwrap();
assert_eq!(
2i32,
tx.query_row::<i32, _, _>("SELECT SUM(x) FROM foo", &[] as &[&ToSql], |r| r.get(0))
tx.query_row::<i32, _, _>("SELECT SUM(x) FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap()
);
}
@ -474,7 +473,7 @@ mod test {
let tx = db.transaction().unwrap();
assert_eq!(
6i32,
tx.query_row::<i32, _, _>("SELECT SUM(x) FROM foo", &[] as &[&ToSql], |r| r.get(0))
tx.query_row::<i32, _, _>("SELECT SUM(x) FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap()
);
}
@ -571,7 +570,7 @@ mod test {
fn assert_current_sum(x: i32, conn: &Connection) {
let i = conn
.query_row::<i32, _, _>("SELECT SUM(x) FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row::<i32, _, _>("SELECT SUM(x) FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(x, i);
}

45
src/types/chrono.rs
View File

@ -132,8 +132,7 @@ mod test {
use super::chrono::{
DateTime, Duration, Local, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc,
};
use types::ToSql;
use Connection;
use {Connection, NO_PARAMS};
fn checked_memory_handle() -> Connection {
let db = Connection::open_in_memory().unwrap();
@ -150,11 +149,11 @@ mod test {
.unwrap();
let s: String = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!("2016-02-23", s);
let t: NaiveDate = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(date, t);
}
@ -167,11 +166,11 @@ mod test {
.unwrap();
let s: String = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!("23:56:04", s);
let v: NaiveTime = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(time, v);
}
@ -187,18 +186,18 @@ mod test {
.unwrap();
let s: String = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!("2016-02-23T23:56:04", s);
let v: NaiveDateTime = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(dt, v);
db.execute("UPDATE foo set b = datetime(t)", &[] as &[&ToSql])
db.execute("UPDATE foo set b = datetime(t)", NO_PARAMS)
.unwrap(); // "YYYY-MM-DD HH:MM:SS"
let hms: NaiveDateTime = db
.query_row("SELECT b FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT b FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(dt, hms);
}
@ -215,33 +214,29 @@ mod test {
.unwrap();
let s: String = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!("2016-02-23T23:56:04.789+00:00", s);
let v1: DateTime<Utc> = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(utc, v1);
let v2: DateTime<Utc> = db
.query_row("SELECT '2016-02-23 23:56:04.789'", &[] as &[&ToSql], |r| {
r.get(0)
}).unwrap();
.query_row("SELECT '2016-02-23 23:56:04.789'", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(utc, v2);
let v3: DateTime<Utc> = db
.query_row("SELECT '2016-02-23 23:56:04'", &[] as &[&ToSql], |r| {
r.get(0)
}).unwrap();
.query_row("SELECT '2016-02-23 23:56:04'", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(utc - Duration::milliseconds(789), v3);
let v4: DateTime<Utc> = db
.query_row(
"SELECT '2016-02-23 23:56:04.789+00:00'",
&[] as &[&ToSql],
|r| r.get(0),
).unwrap();
.query_row("SELECT '2016-02-23 23:56:04.789+00:00'", NO_PARAMS, |r| {
r.get(0)
}).unwrap();
assert_eq!(utc, v4);
}
@ -258,12 +253,12 @@ mod test {
// Stored string should be in UTC
let s: String = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert!(s.ends_with("+00:00"));
let v: DateTime<Local> = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(local, v);
}

24
src/types/mod.rs
View File

@ -115,9 +115,7 @@ mod test {
use super::Value;
use std::f64::EPSILON;
use std::os::raw::{c_double, c_int};
use types::ToSql;
use Connection;
use Error;
use {Connection, Error, NO_PARAMS};
fn checked_memory_handle() -> Connection {
let db = Connection::open_in_memory().unwrap();
@ -135,7 +133,7 @@ mod test {
.unwrap();
let v: Vec<u8> = db
.query_row("SELECT b FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT b FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(v, v1234);
}
@ -149,7 +147,7 @@ mod test {
.unwrap();
let v: Vec<u8> = db
.query_row("SELECT b FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT b FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(v, empty);
}
@ -162,7 +160,7 @@ mod test {
db.execute("INSERT INTO foo(t) VALUES (?)", &[&s]).unwrap();
let from: String = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(from, s);
}
@ -176,7 +174,7 @@ mod test {
.unwrap();
let from: String = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(from, s);
}
@ -190,7 +188,7 @@ mod test {
assert_eq!(
10i64,
db.query_row::<i64, _, _>("SELECT i FROM foo", &[] as &[&ToSql], |r| r.get(0))
db.query_row::<i64, _, _>("SELECT i FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap()
);
}
@ -208,7 +206,7 @@ mod test {
let mut stmt = db
.prepare("SELECT t, b FROM foo ORDER BY ROWID ASC")
.unwrap();
let mut rows = stmt.query(&[] as &[&ToSql]).unwrap();
let mut rows = stmt.query(NO_PARAMS).unwrap();
{
let row1 = rows.next().unwrap().unwrap();
@ -240,11 +238,11 @@ mod test {
db.execute(
"INSERT INTO foo(b, t, i, f) VALUES (X'0102', 'text', 1, 1.5)",
&[] as &[&ToSql],
NO_PARAMS,
).unwrap();
let mut stmt = db.prepare("SELECT b, t, i, f, n FROM foo").unwrap();
let mut rows = stmt.query(&[] as &[&ToSql]).unwrap();
let mut rows = stmt.query(NO_PARAMS).unwrap();
let row = rows.next().unwrap().unwrap();
@ -355,11 +353,11 @@ mod test {
db.execute(
"INSERT INTO foo(b, t, i, f) VALUES (X'0102', 'text', 1, 1.5)",
&[] as &[&ToSql],
NO_PARAMS,
).unwrap();
let mut stmt = db.prepare("SELECT b, t, i, f, n FROM foo").unwrap();
let mut rows = stmt.query(&[] as &[&ToSql]).unwrap();
let mut rows = stmt.query(NO_PARAMS).unwrap();
let row = rows.next().unwrap().unwrap();
assert_eq!(

6
src/types/serde_json.rs
View File

@ -28,7 +28,7 @@ impl FromSql for Value {
mod test {
use super::serde_json;
use types::ToSql;
use Connection;
use {Connection, NO_PARAMS};
fn checked_memory_handle() -> Connection {
let db = Connection::open_in_memory().unwrap();
@ -49,11 +49,11 @@ mod test {
).unwrap();
let t: serde_json::Value = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(data, t);
let b: serde_json::Value = db
.query_row("SELECT b FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT b FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
assert_eq!(data, b);
}

7
src/types/time.rs
View File

@ -32,8 +32,7 @@ impl FromSql for time::Timespec {
#[cfg(test)]
mod test {
use super::time;
use types::ToSql;
use Connection;
use {Connection, NO_PARAMS};
fn checked_memory_handle() -> Connection {
let db = Connection::open_in_memory().unwrap();
@ -59,10 +58,10 @@ mod test {
db.execute("INSERT INTO foo(t) VALUES (?)", &[&ts]).unwrap();
let from: time::Timespec = db
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0))
.unwrap();
db.execute("DELETE FROM foo", &[] as &[&ToSql]).unwrap();
db.execute("DELETE FROM foo", NO_PARAMS).unwrap();
assert_eq!(from, ts);
}

6
src/unlock_notify.rs
View File

@ -102,8 +102,7 @@ mod test {
use std::sync::mpsc::sync_channel;
use std::thread;
use std::time;
use types::ToSql;
use {Connection, OpenFlags, Result, Transaction, TransactionBehavior};
use {Connection, OpenFlags, Result, Transaction, TransactionBehavior, NO_PARAMS};
#[test]
fn test_unlock_notify() {
@ -122,8 +121,7 @@ mod test {
tx2.commit().unwrap();
});
assert_eq!(tx.recv().unwrap(), 1);
let the_answer: Result<i64> =
db1.query_row("SELECT x FROM foo", &[] as &[&ToSql], |r| r.get(0));
let the_answer: Result<i64> = db1.query_row("SELECT x FROM foo", NO_PARAMS, |r| r.get(0));
assert_eq!(42i64, the_answer.unwrap());
child.join().unwrap();
}

7
src/vtab/csvtab.rs
View File

@ -341,8 +341,7 @@ impl From<csv::Error> for Error {
#[cfg(test)]
mod test {
use vtab::csvtab;
use {Connection, Result};
use types::ToSql;
use {Connection, Result, NO_PARAMS};
#[test]
fn test_csv_module() {
@ -359,7 +358,7 @@ mod test {
}
let ids: Result<Vec<i32>> = s
.query_map(&[] as &[&ToSql], |row| row.get::<_, i32>(0))
.query_map(NO_PARAMS, |row| row.get::<_, i32>(0))
.unwrap()
.collect();
let sum = ids.unwrap().iter().fold(0, |acc, &id| acc + id);
@ -382,7 +381,7 @@ mod test {
v1.rowid < v2.rowid",
).unwrap();
let mut rows = s.query(&[] as &[&ToSql]).unwrap();
let mut rows = s.query(NO_PARAMS).unwrap();
let row = rows.next().unwrap().unwrap();
assert_eq!(row.get::<_, i32>(0), 2);
}

5
src/vtab/series.rs
View File

@ -265,8 +265,7 @@ impl VTabCursor for SeriesTabCursor {
mod test {
use ffi;
use vtab::series;
use Connection;
use types::ToSql;
use {Connection, NO_PARAMS};
#[test]
fn test_series_module() {
@ -280,7 +279,7 @@ mod test {
let mut s = db.prepare("SELECT * FROM generate_series(0,20,5)").unwrap();
let series = s.query_map(&[] as &[&ToSql], |row| row.get::<_, i32>(0)).unwrap();
let series = s.query_map(NO_PARAMS, |row| row.get::<_, i32>(0)).unwrap();
let mut expected = 0;
for value in series {