aboutsummaryrefslogtreecommitdiff
path: root/src/types
diff options
context:
space:
mode:
Diffstat (limited to 'src/types')
-rw-r--r--src/types/chrono.rs92
-rw-r--r--src/types/from_sql.rs6
-rw-r--r--src/types/mod.rs29
-rw-r--r--src/types/serde_json.rs106
-rw-r--r--src/types/time.rs15
-rw-r--r--src/types/to_sql.rs36
-rw-r--r--src/types/url.rs2
7 files changed, 180 insertions, 106 deletions
diff --git a/src/types/chrono.rs b/src/types/chrono.rs
index 6bfc2f4..6b50e01 100644
--- a/src/types/chrono.rs
+++ b/src/types/chrono.rs
@@ -175,12 +175,12 @@ mod test {
#[test]
fn test_naive_date() -> Result<()> {
let db = checked_memory_handle()?;
- let date = NaiveDate::from_ymd(2016, 2, 23);
- db.execute("INSERT INTO foo (t) VALUES (?)", [date])?;
+ let date = NaiveDate::from_ymd_opt(2016, 2, 23).unwrap();
+ db.execute("INSERT INTO foo (t) VALUES (?1)", [date])?;
- let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let s: String = db.one_column("SELECT t FROM foo")?;
assert_eq!("2016-02-23", s);
- let t: NaiveDate = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let t: NaiveDate = db.one_column("SELECT t FROM foo")?;
assert_eq!(date, t);
Ok(())
}
@@ -188,12 +188,12 @@ mod test {
#[test]
fn test_naive_time() -> Result<()> {
let db = checked_memory_handle()?;
- let time = NaiveTime::from_hms(23, 56, 4);
- db.execute("INSERT INTO foo (t) VALUES (?)", [time])?;
+ let time = NaiveTime::from_hms_opt(23, 56, 4).unwrap();
+ db.execute("INSERT INTO foo (t) VALUES (?1)", [time])?;
- let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let s: String = db.one_column("SELECT t FROM foo")?;
assert_eq!("23:56:04", s);
- let v: NaiveTime = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let v: NaiveTime = db.one_column("SELECT t FROM foo")?;
assert_eq!(time, v);
Ok(())
}
@@ -201,19 +201,19 @@ mod test {
#[test]
fn test_naive_date_time() -> Result<()> {
let db = checked_memory_handle()?;
- let date = NaiveDate::from_ymd(2016, 2, 23);
- let time = NaiveTime::from_hms(23, 56, 4);
+ let date = NaiveDate::from_ymd_opt(2016, 2, 23).unwrap();
+ let time = NaiveTime::from_hms_opt(23, 56, 4).unwrap();
let dt = NaiveDateTime::new(date, time);
- db.execute("INSERT INTO foo (t) VALUES (?)", [dt])?;
+ db.execute("INSERT INTO foo (t) VALUES (?1)", [dt])?;
- let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let s: String = db.one_column("SELECT t FROM foo")?;
assert_eq!("2016-02-23 23:56:04", s);
- let v: NaiveDateTime = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let v: NaiveDateTime = db.one_column("SELECT t FROM foo")?;
assert_eq!(dt, v);
db.execute("UPDATE foo set b = datetime(t)", [])?; // "YYYY-MM-DD HH:MM:SS"
- let hms: NaiveDateTime = db.query_row("SELECT b FROM foo", [], |r| r.get(0))?;
+ let hms: NaiveDateTime = db.one_column("SELECT b FROM foo")?;
assert_eq!(dt, hms);
Ok(())
}
@@ -221,28 +221,26 @@ mod test {
#[test]
fn test_date_time_utc() -> Result<()> {
let db = checked_memory_handle()?;
- let date = NaiveDate::from_ymd(2016, 2, 23);
- let time = NaiveTime::from_hms_milli(23, 56, 4, 789);
+ let date = NaiveDate::from_ymd_opt(2016, 2, 23).unwrap();
+ let time = NaiveTime::from_hms_milli_opt(23, 56, 4, 789).unwrap();
let dt = NaiveDateTime::new(date, time);
let utc = Utc.from_utc_datetime(&dt);
- db.execute("INSERT INTO foo (t) VALUES (?)", [utc])?;
+ db.execute("INSERT INTO foo (t) VALUES (?1)", [utc])?;
- let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let s: String = db.one_column("SELECT t FROM foo")?;
assert_eq!("2016-02-23 23:56:04.789+00:00", s);
- let v1: DateTime<Utc> = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let v1: DateTime<Utc> = db.one_column("SELECT t FROM foo")?;
assert_eq!(utc, v1);
- let v2: DateTime<Utc> =
- db.query_row("SELECT '2016-02-23 23:56:04.789'", [], |r| r.get(0))?;
+ let v2: DateTime<Utc> = db.one_column("SELECT '2016-02-23 23:56:04.789'")?;
assert_eq!(utc, v2);
- let v3: DateTime<Utc> = db.query_row("SELECT '2016-02-23 23:56:04'", [], |r| r.get(0))?;
+ let v3: DateTime<Utc> = db.one_column("SELECT '2016-02-23 23:56:04'")?;
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))?;
+ let v4: DateTime<Utc> = db.one_column("SELECT '2016-02-23 23:56:04.789+00:00'")?;
assert_eq!(utc, v4);
Ok(())
}
@@ -250,18 +248,18 @@ mod test {
#[test]
fn test_date_time_local() -> Result<()> {
let db = checked_memory_handle()?;
- let date = NaiveDate::from_ymd(2016, 2, 23);
- let time = NaiveTime::from_hms_milli(23, 56, 4, 789);
+ let date = NaiveDate::from_ymd_opt(2016, 2, 23).unwrap();
+ let time = NaiveTime::from_hms_milli_opt(23, 56, 4, 789).unwrap();
let dt = NaiveDateTime::new(date, time);
let local = Local.from_local_datetime(&dt).single().unwrap();
- db.execute("INSERT INTO foo (t) VALUES (?)", [local])?;
+ db.execute("INSERT INTO foo (t) VALUES (?1)", [local])?;
// Stored string should be in UTC
- let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let s: String = db.one_column("SELECT t FROM foo")?;
assert!(s.ends_with("+00:00"));
- let v: DateTime<Local> = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let v: DateTime<Local> = db.one_column("SELECT t FROM foo")?;
assert_eq!(local, v);
Ok(())
}
@@ -271,13 +269,13 @@ mod test {
let db = checked_memory_handle()?;
let time = DateTime::parse_from_rfc3339("2020-04-07T11:23:45+04:00").unwrap();
- db.execute("INSERT INTO foo (t) VALUES (?)", [time])?;
+ db.execute("INSERT INTO foo (t) VALUES (?1)", [time])?;
// Stored string should preserve timezone offset
- let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let s: String = db.one_column("SELECT t FROM foo")?;
assert!(s.ends_with("+04:00"));
- let v: DateTime<FixedOffset> = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let v: DateTime<FixedOffset> = db.one_column("SELECT t FROM foo")?;
assert_eq!(time.offset(), v.offset());
assert_eq!(time, v);
Ok(())
@@ -286,38 +284,36 @@ mod test {
#[test]
fn test_sqlite_functions() -> Result<()> {
let db = checked_memory_handle()?;
- let result: Result<NaiveTime> = db.query_row("SELECT CURRENT_TIME", [], |r| r.get(0));
- assert!(result.is_ok());
- let result: Result<NaiveDate> = db.query_row("SELECT CURRENT_DATE", [], |r| r.get(0));
- assert!(result.is_ok());
- let result: Result<NaiveDateTime> =
- db.query_row("SELECT CURRENT_TIMESTAMP", [], |r| r.get(0));
- assert!(result.is_ok());
- let result: Result<DateTime<Utc>> =
- db.query_row("SELECT CURRENT_TIMESTAMP", [], |r| r.get(0));
- assert!(result.is_ok());
+ let result: Result<NaiveTime> = db.one_column("SELECT CURRENT_TIME");
+ result.unwrap();
+ let result: Result<NaiveDate> = db.one_column("SELECT CURRENT_DATE");
+ result.unwrap();
+ let result: Result<NaiveDateTime> = db.one_column("SELECT CURRENT_TIMESTAMP");
+ result.unwrap();
+ let result: Result<DateTime<Utc>> = db.one_column("SELECT CURRENT_TIMESTAMP");
+ result.unwrap();
Ok(())
}
#[test]
fn test_naive_date_time_param() -> Result<()> {
let db = checked_memory_handle()?;
- let result: Result<bool> = db.query_row("SELECT 1 WHERE ? BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now().naive_utc()], |r| r.get(0));
- assert!(result.is_ok());
+ let result: Result<bool> = db.query_row("SELECT 1 WHERE ?1 BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now().naive_utc()], |r| r.get(0));
+ result.unwrap();
Ok(())
}
#[test]
fn test_date_time_param() -> Result<()> {
let db = checked_memory_handle()?;
- let result: Result<bool> = db.query_row("SELECT 1 WHERE ? BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now()], |r| r.get(0));
- assert!(result.is_ok());
+ let result: Result<bool> = db.query_row("SELECT 1 WHERE ?1 BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now()], |r| r.get(0));
+ result.unwrap();
Ok(())
}
#[test]
fn test_lenient_parse_timezone() {
- assert!(DateTime::<Utc>::column_result(ValueRef::Text(b"1970-01-01T00:00:00Z")).is_ok());
- assert!(DateTime::<Utc>::column_result(ValueRef::Text(b"1970-01-01T00:00:00+00")).is_ok());
+ DateTime::<Utc>::column_result(ValueRef::Text(b"1970-01-01T00:00:00Z")).unwrap();
+ DateTime::<Utc>::column_result(ValueRef::Text(b"1970-01-01T00:00:00+00")).unwrap();
}
}
diff --git a/src/types/from_sql.rs b/src/types/from_sql.rs
index b95a378..91eed09 100644
--- a/src/types/from_sql.rs
+++ b/src/types/from_sql.rs
@@ -52,7 +52,7 @@ impl fmt::Display for FromSqlError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
FromSqlError::InvalidType => write!(f, "Invalid type"),
- FromSqlError::OutOfRange(i) => write!(f, "Value {} out of range", i),
+ FromSqlError::OutOfRange(i) => write!(f, "Value {i} out of range"),
FromSqlError::InvalidBlobSize {
expected_size,
blob_size,
@@ -244,7 +244,7 @@ mod test {
{
for n in out_of_range {
let err = db
- .query_row("SELECT ?", &[n], |r| r.get::<_, T>(0))
+ .query_row("SELECT ?1", [n], |r| r.get::<_, T>(0))
.unwrap_err();
match err {
Error::IntegralValueOutOfRange(_, value) => assert_eq!(*n, value),
@@ -254,7 +254,7 @@ mod test {
for n in in_range {
assert_eq!(
*n,
- db.query_row("SELECT ?", &[n], |r| r.get::<_, T>(0))
+ db.query_row("SELECT ?1", [n], |r| r.get::<_, T>(0))
.unwrap()
.into()
);
diff --git a/src/types/mod.rs b/src/types/mod.rs
index 4000ae2..eece984 100644
--- a/src/types/mod.rs
+++ b/src/types/mod.rs
@@ -102,7 +102,7 @@ mod value_ref;
/// # use rusqlite::types::{Null};
///
/// fn insert_null(conn: &Connection) -> Result<usize> {
-/// conn.execute("INSERT INTO people (name) VALUES (?)", [Null])
+/// conn.execute("INSERT INTO people (name) VALUES (?1)", [Null])
/// }
/// ```
#[derive(Copy, Clone)]
@@ -153,9 +153,9 @@ mod test {
let db = checked_memory_handle()?;
let v1234 = vec![1u8, 2, 3, 4];
- db.execute("INSERT INTO foo(b) VALUES (?)", &[&v1234])?;
+ db.execute("INSERT INTO foo(b) VALUES (?1)", [&v1234])?;
- let v: Vec<u8> = db.query_row("SELECT b FROM foo", [], |r| r.get(0))?;
+ let v: Vec<u8> = db.one_column("SELECT b FROM foo")?;
assert_eq!(v, v1234);
Ok(())
}
@@ -165,9 +165,9 @@ mod test {
let db = checked_memory_handle()?;
let empty = vec![];
- db.execute("INSERT INTO foo(b) VALUES (?)", &[&empty])?;
+ db.execute("INSERT INTO foo(b) VALUES (?1)", [&empty])?;
- let v: Vec<u8> = db.query_row("SELECT b FROM foo", [], |r| r.get(0))?;
+ let v: Vec<u8> = db.one_column("SELECT b FROM foo")?;
assert_eq!(v, empty);
Ok(())
}
@@ -177,9 +177,9 @@ mod test {
let db = checked_memory_handle()?;
let s = "hello, world!";
- db.execute("INSERT INTO foo(t) VALUES (?)", &[&s])?;
+ db.execute("INSERT INTO foo(t) VALUES (?1)", [&s])?;
- let from: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let from: String = db.one_column("SELECT t FROM foo")?;
assert_eq!(from, s);
Ok(())
}
@@ -189,9 +189,9 @@ 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 (?1)", [s.to_owned()])?;
- let from: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let from: String = db.one_column("SELECT t FROM foo")?;
assert_eq!(from, s);
Ok(())
}
@@ -200,12 +200,9 @@ mod test {
fn test_value() -> Result<()> {
let db = checked_memory_handle()?;
- db.execute("INSERT INTO foo(i) VALUES (?)", [Value::Integer(10)])?;
+ db.execute("INSERT INTO foo(i) VALUES (?1)", [Value::Integer(10)])?;
- assert_eq!(
- 10i64,
- db.query_row::<i64, _, _>("SELECT i FROM foo", [], |r| r.get(0))?
- );
+ assert_eq!(10i64, db.one_column::<i64>("SELECT i FROM foo")?);
Ok(())
}
@@ -216,8 +213,8 @@ mod test {
let s = Some("hello, world!");
let b = Some(vec![1u8, 2, 3, 4]);
- db.execute("INSERT INTO foo(t) VALUES (?)", &[&s])?;
- db.execute("INSERT INTO foo(b) VALUES (?)", &[&b])?;
+ db.execute("INSERT INTO foo(t) VALUES (?1)", [&s])?;
+ db.execute("INSERT INTO foo(b) VALUES (?1)", [&b])?;
let mut stmt = db.prepare("SELECT t, b FROM foo ORDER BY ROWID ASC")?;
let mut rows = stmt.query([])?;
diff --git a/src/types/serde_json.rs b/src/types/serde_json.rs
index a9761bd..6e38ba3 100644
--- a/src/types/serde_json.rs
+++ b/src/types/serde_json.rs
@@ -1,24 +1,62 @@
//! [`ToSql`] and [`FromSql`] implementation for JSON `Value`.
-use serde_json::Value;
+use serde_json::{Number, Value};
use crate::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef};
-use crate::Result;
+use crate::{Error, Result};
-/// Serialize JSON `Value` to text.
+/// Serialize JSON `Value` to text:
+///
+///
+/// | JSON | SQLite |
+/// |----------|---------|
+/// | Null | NULL |
+/// | Bool | 'true' / 'false' |
+/// | Number | INT or REAL except u64 |
+/// | _ | TEXT |
impl ToSql for Value {
#[inline]
fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
- Ok(ToSqlOutput::from(serde_json::to_string(self).unwrap()))
+ match self {
+ Value::Null => Ok(ToSqlOutput::Borrowed(ValueRef::Null)),
+ Value::Number(n) if n.is_i64() => Ok(ToSqlOutput::from(n.as_i64().unwrap())),
+ Value::Number(n) if n.is_f64() => Ok(ToSqlOutput::from(n.as_f64().unwrap())),
+ _ => serde_json::to_string(self)
+ .map(ToSqlOutput::from)
+ .map_err(|err| Error::ToSqlConversionFailure(err.into())),
+ }
}
}
-/// Deserialize text/blob to JSON `Value`.
+/// Deserialize SQLite value to JSON `Value`:
+///
+/// | SQLite | JSON |
+/// |----------|---------|
+/// | NULL | Null |
+/// | 'null' | Null |
+/// | 'true' | Bool |
+/// | 1 | Number |
+/// | 0.1 | Number |
+/// | '"text"' | String |
+/// | 'text' | _Error_ |
+/// | '[0, 1]' | Array |
+/// | '{"x": 1}' | Object |
impl FromSql for Value {
#[inline]
fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
- let bytes = value.as_bytes()?;
- serde_json::from_slice(bytes).map_err(|err| FromSqlError::Other(Box::new(err)))
+ match value {
+ ValueRef::Text(s) => serde_json::from_slice(s), // KO for b"text"
+ ValueRef::Blob(b) => serde_json::from_slice(b),
+ ValueRef::Integer(i) => Ok(Value::Number(Number::from(i))),
+ ValueRef::Real(f) => {
+ match Number::from_f64(f) {
+ Some(n) => Ok(Value::Number(n)),
+ _ => return Err(FromSqlError::InvalidType), // FIXME
+ }
+ }
+ ValueRef::Null => Ok(Value::Null),
+ }
+ .map_err(|err| FromSqlError::Other(Box::new(err)))
}
}
@@ -26,6 +64,7 @@ impl FromSql for Value {
mod test {
use crate::types::ToSql;
use crate::{Connection, Result};
+ use serde_json::{Number, Value};
fn checked_memory_handle() -> Result<Connection> {
let db = Connection::open_in_memory()?;
@@ -38,16 +77,59 @@ mod test {
let db = checked_memory_handle()?;
let json = r#"{"foo": 13, "bar": "baz"}"#;
- let data: serde_json::Value = serde_json::from_str(json).unwrap();
+ let data: Value = serde_json::from_str(json).unwrap();
db.execute(
- "INSERT INTO foo (t, b) VALUES (?, ?)",
- &[&data as &dyn ToSql, &json.as_bytes()],
+ "INSERT INTO foo (t, b) VALUES (?1, ?2)",
+ [&data as &dyn ToSql, &json.as_bytes()],
)?;
- let t: serde_json::Value = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let t: Value = db.one_column("SELECT t FROM foo")?;
assert_eq!(data, t);
- let b: serde_json::Value = db.query_row("SELECT b FROM foo", [], |r| r.get(0))?;
+ let b: Value = db.one_column("SELECT b FROM foo")?;
assert_eq!(data, b);
Ok(())
}
+
+ #[test]
+ fn test_to_sql() -> Result<()> {
+ let db = Connection::open_in_memory()?;
+
+ let v: Option<String> = db.query_row("SELECT ?", [Value::Null], |r| r.get(0))?;
+ assert_eq!(None, v);
+ let v: String = db.query_row("SELECT ?", [Value::Bool(true)], |r| r.get(0))?;
+ assert_eq!("true", v);
+ let v: i64 = db.query_row("SELECT ?", [Value::Number(Number::from(1))], |r| r.get(0))?;
+ assert_eq!(1, v);
+ let v: f64 = db.query_row(
+ "SELECT ?",
+ [Value::Number(Number::from_f64(0.1).unwrap())],
+ |r| r.get(0),
+ )?;
+ assert_eq!(0.1, v);
+ let v: String =
+ db.query_row("SELECT ?", [Value::String("text".to_owned())], |r| r.get(0))?;
+ assert_eq!("\"text\"", v);
+ Ok(())
+ }
+
+ #[test]
+ fn test_from_sql() -> Result<()> {
+ let db = Connection::open_in_memory()?;
+
+ let v: Value = db.one_column("SELECT NULL")?;
+ assert_eq!(Value::Null, v);
+ let v: Value = db.one_column("SELECT 'null'")?;
+ assert_eq!(Value::Null, v);
+ let v: Value = db.one_column("SELECT 'true'")?;
+ assert_eq!(Value::Bool(true), v);
+ let v: Value = db.one_column("SELECT 1")?;
+ assert_eq!(Value::Number(Number::from(1)), v);
+ let v: Value = db.one_column("SELECT 0.1")?;
+ assert_eq!(Value::Number(Number::from_f64(0.1).unwrap()), v);
+ let v: Value = db.one_column("SELECT '\"text\"'")?;
+ assert_eq!(Value::String("text".to_owned()), v);
+ let v: Result<Value> = db.one_column("SELECT 'text'");
+ assert!(v.is_err());
+ Ok(())
+ }
}
diff --git a/src/types/time.rs b/src/types/time.rs
index 4e2811e..03b2d61 100644
--- a/src/types/time.rs
+++ b/src/types/time.rs
@@ -91,9 +91,9 @@ mod test {
ts_vec.push(make_datetime(10_000_000_000, 0)); //November 20, 2286
for ts in ts_vec {
- db.execute("INSERT INTO foo(t) VALUES (?)", [ts])?;
+ db.execute("INSERT INTO foo(t) VALUES (?1)", [ts])?;
- let from: OffsetDateTime = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
+ let from: OffsetDateTime = db.one_column("SELECT t FROM foo")?;
db.execute("DELETE FROM foo", [])?;
@@ -143,7 +143,7 @@ mod test {
Ok(OffsetDateTime::parse("2013-10-07T04:23:19.120-04:00", &Rfc3339).unwrap()),
),
] {
- let result: Result<OffsetDateTime> = db.query_row("SELECT ?", [s], |r| r.get(0));
+ let result: Result<OffsetDateTime> = db.query_row("SELECT ?1", [s], |r| r.get(0));
assert_eq!(result, t);
}
Ok(())
@@ -152,17 +152,16 @@ mod test {
#[test]
fn test_sqlite_functions() -> Result<()> {
let db = Connection::open_in_memory()?;
- let result: Result<OffsetDateTime> =
- db.query_row("SELECT CURRENT_TIMESTAMP", [], |r| r.get(0));
- assert!(result.is_ok());
+ let result: Result<OffsetDateTime> = db.one_column("SELECT CURRENT_TIMESTAMP");
+ result.unwrap();
Ok(())
}
#[test]
fn test_param() -> Result<()> {
let db = Connection::open_in_memory()?;
- let result: Result<bool> = db.query_row("SELECT 1 WHERE ? BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [OffsetDateTime::now_utc()], |r| r.get(0));
- assert!(result.is_ok());
+ let result: Result<bool> = db.query_row("SELECT 1 WHERE ?1 BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [OffsetDateTime::now_utc()], |r| r.get(0));
+ result.unwrap();
Ok(())
}
}
diff --git a/src/types/to_sql.rs b/src/types/to_sql.rs
index 4e0d882..c2bc007 100644
--- a/src/types/to_sql.rs
+++ b/src/types/to_sql.rs
@@ -278,7 +278,7 @@ mod test {
let _a: &[&dyn ToSql] = crate::params![a];
let r = ToSql::to_sql(&a);
- assert!(r.is_ok());
+ r.unwrap();
}
#[test]
@@ -287,10 +287,10 @@ mod test {
let s = "str";
let cow: Cow<str> = Cow::Borrowed(s);
let r = cow.to_sql();
- assert!(r.is_ok());
+ r.unwrap();
let cow: Cow<str> = Cow::Owned::<str>(String::from(s));
let r = cow.to_sql();
- assert!(r.is_ok());
+ r.unwrap();
// Ensure this compiles.
let _p: &[&dyn ToSql] = crate::params![cow];
}
@@ -301,7 +301,7 @@ mod test {
let _s: &[&dyn ToSql] = crate::params![s];
let r = ToSql::to_sql(&s);
- assert!(r.is_ok());
+ r.unwrap();
}
#[test]
@@ -310,7 +310,7 @@ mod test {
let _s: &[&dyn ToSql] = crate::params![s];
let r = s.to_sql();
- assert!(r.is_ok());
+ r.unwrap();
}
#[test]
@@ -319,7 +319,7 @@ mod test {
let _s: &[&dyn ToSql] = crate::params![s];
let r = ToSql::to_sql(&s);
- assert!(r.is_ok());
+ r.unwrap();
}
#[test]
@@ -331,32 +331,32 @@ mod test {
let s: Rc<Box<str>> = Rc::new(source_str.clone());
let _s: &[&dyn ToSql] = crate::params![s];
let r = s.to_sql();
- assert!(r.is_ok());
+ r.unwrap();
let s: Arc<Box<str>> = Arc::new(source_str.clone());
let _s: &[&dyn ToSql] = crate::params![s];
let r = s.to_sql();
- assert!(r.is_ok());
+ r.unwrap();
let s: Arc<str> = Arc::from(&*source_str);
let _s: &[&dyn ToSql] = crate::params![s];
let r = s.to_sql();
- assert!(r.is_ok());
+ r.unwrap();
let s: Arc<dyn ToSql> = Arc::new(source_str.clone());
let _s: &[&dyn ToSql] = crate::params![s];
let r = s.to_sql();
- assert!(r.is_ok());
+ r.unwrap();
let s: Rc<str> = Rc::from(&*source_str);
let _s: &[&dyn ToSql] = crate::params![s];
let r = s.to_sql();
- assert!(r.is_ok());
+ r.unwrap();
let s: Rc<dyn ToSql> = Rc::new(source_str);
let _s: &[&dyn ToSql] = crate::params![s];
let r = s.to_sql();
- assert!(r.is_ok());
+ r.unwrap();
}
#[cfg(feature = "i128_blob")]
@@ -368,10 +368,10 @@ mod test {
db.execute(
"
INSERT INTO foo(i128, desc) VALUES
- (?, 'zero'),
- (?, 'neg one'), (?, 'neg two'),
- (?, 'pos one'), (?, 'pos two'),
- (?, 'min'), (?, 'max')",
+ (?1, 'zero'),
+ (?2, 'neg one'), (?3, 'neg two'),
+ (?4, 'pos one'), (?5, 'pos two'),
+ (?6, 'min'), (?7, 'max')",
[0i128, -1i128, -2i128, 1i128, 2i128, i128::MIN, i128::MAX],
)?;
@@ -410,11 +410,11 @@ mod test {
let id = Uuid::new_v4();
db.execute(
- "INSERT INTO foo (id, label) VALUES (?, ?)",
+ "INSERT INTO foo (id, label) VALUES (?1, ?2)",
params![id, "target"],
)?;
- let mut stmt = db.prepare("SELECT id, label FROM foo WHERE id = ?")?;
+ let mut stmt = db.prepare("SELECT id, label FROM foo WHERE id = ?1")?;
let mut rows = stmt.query(params![id])?;
let row = rows.next()?.unwrap();
diff --git a/src/types/url.rs b/src/types/url.rs
index fea8500..0ebb59b 100644
--- a/src/types/url.rs
+++ b/src/types/url.rs
@@ -49,7 +49,7 @@ mod test {
let url2 = "http://www.example2.com/👌";
db.execute(
- "INSERT INTO urls (i, v) VALUES (0, ?), (1, ?), (2, ?), (3, ?)",
+ "INSERT INTO urls (i, v) VALUES (0, ?1), (1, ?2), (2, ?3), (3, ?4)",
// also insert a non-hex encoded url (which might be present if it was
// inserted separately)
params![url0, url1, url2, "illegal"],
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-20 09:26:47 +0000