ISAR/rusqlite
3
0
Fork 0
mirror of https://github.com/isar/rusqlite.git synced 2025-10-19 06:18:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

Take IntoIterator rather than &[&ToSql] (#312)

Browse Source
This commit is contained in:
gwenn
2018-09-16 09:49:23 +02:00
parent bd1756adef
commit c4ae541eac
18 changed files with 341 additions and 235 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
src/types/chrono.rs
View File

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

27
src/types/mod.rs
View File

@@ -81,7 +81,7 @@ mod value_ref;
/// # use rusqlite::types::{Null};
/// fn main() {}
/// fn insert_null(conn: &Connection) -> Result<usize> {
/// conn.execute("INSERT INTO people (name) VALUES (?)", &[&Null])
/// conn.execute("INSERT INTO people (name) VALUES (?)", &[Null])
/// }
/// ```
#[derive(Copy, Clone)]
@@ -115,6 +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;
@@ -134,7 +135,7 @@ mod test {
.unwrap();
let v: Vec<u8> = db
.query_row("SELECT b FROM foo", &[], |r| r.get(0))
.query_row("SELECT b FROM foo", &[] as &[&ToSql], |r| r.get(0))
.unwrap();
assert_eq!(v, v1234);
}
@@ -148,7 +149,7 @@ mod test {
.unwrap();
let v: Vec<u8> = db
.query_row("SELECT b FROM foo", &[], |r| r.get(0))
.query_row("SELECT b FROM foo", &[] as &[&ToSql], |r| r.get(0))
.unwrap();
assert_eq!(v, empty);
}
@@ -161,7 +162,7 @@ mod test {
db.execute("INSERT INTO foo(t) VALUES (?)", &[&s]).unwrap();
let from: String = db
.query_row("SELECT t FROM foo", &[], |r| r.get(0))
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.unwrap();
assert_eq!(from, s);
}
@@ -171,11 +172,11 @@ mod test {
let db = checked_memory_handle();
let s = "hello, world!";
db.execute("INSERT INTO foo(t) VALUES (?)", &[&s.to_owned()])
db.execute("INSERT INTO foo(t) VALUES (?)", &[s.to_owned()])
.unwrap();
let from: String = db
.query_row("SELECT t FROM foo", &[], |r| r.get(0))
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.unwrap();
assert_eq!(from, s);
}
@@ -184,12 +185,12 @@ mod test {
fn test_value() {
let db = checked_memory_handle();
db.execute("INSERT INTO foo(i) VALUES (?)", &[&Value::Integer(10)])
db.execute("INSERT INTO foo(i) VALUES (?)", &[Value::Integer(10)])
.unwrap();
assert_eq!(
10i64,
db.query_row::<i64, _>("SELECT i FROM foo", &[], |r| r.get(0))
db.query_row::<i64, _, _>("SELECT i FROM foo", &[] as &[&ToSql], |r| r.get(0))
.unwrap()
);
}
@@ -207,7 +208,7 @@ mod test {
let mut stmt = db
.prepare("SELECT t, b FROM foo ORDER BY ROWID ASC")
.unwrap();
let mut rows = stmt.query(&[]).unwrap();
let mut rows = stmt.query(&[] as &[&ToSql]).unwrap();
{
let row1 = rows.next().unwrap().unwrap();
@@ -239,11 +240,11 @@ mod test {
db.execute(
"INSERT INTO foo(b, t, i, f) VALUES (X'0102', 'text', 1, 1.5)",
&[],
&[] as &[&ToSql],
).unwrap();
let mut stmt = db.prepare("SELECT b, t, i, f, n FROM foo").unwrap();
let mut rows = stmt.query(&[]).unwrap();
let mut rows = stmt.query(&[] as &[&ToSql]).unwrap();
let row = rows.next().unwrap().unwrap();
@@ -354,11 +355,11 @@ mod test {
db.execute(
"INSERT INTO foo(b, t, i, f) VALUES (X'0102', 'text', 1, 1.5)",
&[],
&[] as &[&ToSql],
).unwrap();
let mut stmt = db.prepare("SELECT b, t, i, f, n FROM foo").unwrap();
let mut rows = stmt.query(&[]).unwrap();
let mut rows = stmt.query(&[] as &[&ToSql]).unwrap();
let row = rows.next().unwrap().unwrap();
assert_eq!(

7
src/types/serde_json.rs
View File

@@ -27,6 +27,7 @@ impl FromSql for Value {
#[cfg(test)]
mod test {
use super::serde_json;
use types::ToSql;
use Connection;
fn checked_memory_handle() -> Connection {
@@ -44,15 +45,15 @@ mod test {
let data: serde_json::Value = serde_json::from_str(json).unwrap();
db.execute(
"INSERT INTO foo (t, b) VALUES (?, ?)",
&[&data, &json.as_bytes()],
&[&data as &ToSql, &json.as_bytes()],
).unwrap();
let t: serde_json::Value = db
.query_row("SELECT t FROM foo", &[], |r| r.get(0))
.query_row("SELECT t FROM foo", &[] as &[&ToSql], |r| r.get(0))
.unwrap();
assert_eq!(data, t);
let b: serde_json::Value = db
.query_row("SELECT b FROM foo", &[], |r| r.get(0))
.query_row("SELECT b FROM foo", &[] as &[&ToSql], |r| r.get(0))
.unwrap();
assert_eq!(data, b);
}

5
src/types/time.rs
View File

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

4
src/types/to_sql.rs
View File

@@ -114,10 +114,10 @@ to_sql_self!(f64);
impl<'a, T: ?Sized> ToSql for &'a T
where
&'a T: Into<ToSqlOutput<'a>>,
T: ToSql,
{
fn to_sql(&self) -> Result<ToSqlOutput> {
Ok((*self).into())
(*self).to_sql()
}
}