Add this to your Cargo.toml:
[dependencies]
serde_rusqlite = "0.18"
This crate provides convenience functions to bridge serde and rusqlite. With their help
you can "deserialize" rusqlite Row's into serde Deserialize types and "serialize" types
implementing Serialize into bound query arguments (positional or named) that rusqlite expects.
Serialization of named bound arguments is only supported from structs and maps because other
serde types lack column name information. Likewise, serialization of positional bound arguments
is only supported from tuples, sequences and primitive non-iterable types. In the latter case
the result will be single-element vector. Each serialized field or element must implement
rusqlite::types::ToSql.
For deserialization you can use two families of functions: from_*() and from_*_with_columns().
The most used one is the former. The latter allows you to specify column names for types that need
them, but don't supply them. This includes different Map types like HashMap. Specifying columns
for deserialization into e.g. struct doesn't have any effect as the field list of the struct itself
will be used in any case.
SQLite only supports 5 types: NULL (None), INTEGER (i64), REAL (f64), TEXT (String)
and BLOB (Vec<u8>). Corresponding rust types are inside brackets.
Some types employ non-trivial handling, these are described below:
u64 will fail if it can't be represented by i64 due to sqlite limitations.Simple enums will be serialized as strings so:
enum Gender {
M,
F,
}
will have two possible TEXT options in the database "M" and "F". Deserialization into enum
from TEXT is also supported.
bools are serialized as INTEGERs 0 or 1, can be deserialized from INTEGER and REAL where
0 and 0.0 are false, anything else is true.f64 and f32 values of NaN are serialized as NULLs. When deserializing such value Option<f64>
will have value of None and f64 will have value of NaN. The same applies to f32.Bytes, ByteBuf from serde_bytes are supported as optimized way of handling BLOBs.unit serializes to NULL.sequences of u8 are serialized and deserialized, BLOB database type is used. It's
more optimal though to use Bytes and ByteBuf from serde_bytes for such fields.unit_struct serializes to struct name as TEXT, when deserializing the check is made to ensure
that struct name coincides with the string in the database.```rust extern crate rusqlite;
extern crate serdederive; extern crate serderusqlite;
use serderusqlite::*; use rusqlite::NOPARAMS;
struct Example { id: i64, name: String, }
fn main() { let connection = rusqlite::Connection::openinmemory().unwrap(); connection.execute("CREATE TABLE example (id INT, name TEXT)", NO_PARAMS).unwrap();
// using structure to generate named bound query arguments let row1 = Example{ id: 1, name: "first name".into() }; connection.executenamed("INSERT INTO example (id, name) VALUES (:id, :name)", &toparamsnamed(&row1).unwrap().toslice()).unwrap();
// using tuple to generate positional bound query arguments let row2 = (2, "second name"); connection.execute("INSERT INTO example (id, name) VALUES (?, ?)", &toparams(&row2).unwrap().toslice()).unwrap();
// deserializing using query() and fromrows()
let mut statement = connection.prepare("SELECT * FROM example").unwrap();
let mut res = fromrows::
// deserializing using queryandthen() and fromrow()
let mut statement = connection.prepare("SELECT * FROM example").unwrap();
let mut rows = statement.queryandthen(NOPARAMS, fromrow::
// deserializing using query() and fromrowsref()
let mut statement = connection.prepare("SELECT * FROM example").unwrap();
let mut rows = statement.query(NOPARAMS).unwrap();
{
// only first record is deserialized here
let mut res = fromrowsref::
// deserializing using query() and fromrowswithcolumns()
let mut statement = connection.prepare("SELECT * FROM example").unwrap();
let columns = columnsfromstatement(&statement);
let mut res = fromrowswithcolumns::
// deserializing using queryandthen() and fromrowwithcolumns()
let mut statement = connection.prepare("SELECT * FROM example").unwrap();
let columns = columnsfromstatement(&statement);
let mut rows = statement.queryandthen(NOPARAMS, |row| fromrowwithcolumns::
// deserializing using query() and fromrowsrefwithcolumns()
let mut statement = connection.prepare("SELECT * FROM example").unwrap();
let columns = columnsfromstatement(&statement);
let mut rows = statement.query(NOPARAMS).unwrap();
{
// only first record is deserialized here
let mut res = fromrowsrefwithcolumns::
} ```
License: LGPL-3.0