Struct SqlVec 

pub struct SqlVec<T: ToString + FromStr>(/* private fields */);

A generic container for vectors whose contents implement ToString & FromStr.

SqlVec implements ToSql & FromSql storing values as \u{F1} delimited text, allowing for SQL operations.

Example

 use sqlvec::SqlVec;
 use rusqlite::{Error, Connection, params};

 let conn = Connection::open_in_memory().unwrap();

 // Create a table with a column that uses our custom type.
 conn.execute(
     "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, data TEXT);",
     [],
 ).unwrap();

 // Insert a SqlVec into the table.
 let values = SqlVec::new(vec!["one".to_string(), "two".to_string()]);
 conn.execute(
     "INSERT INTO test (data) VALUES (?1)",
     params![values],
 ).unwrap();

 // Retrieve the SqlVec from the table.
 let mut stmt = conn.prepare("SELECT data FROM test WHERE id = ?1").unwrap();
 let mut rows = stmt.query(params![1]).unwrap();
 let row = rows.next().unwrap().unwrap();
 let db_values: SqlVec<String> = row.get(0).unwrap();

 // Assert that the retrieved SqlVec matches the original.
 assert_eq!(values, db_values);

Implementations

impl<T: ToString + FromStr> SqlVec<T>

pub fn new<I: IntoIterator<Item = T>>(items: I) -> Self

Creates a new SqlVec from an iterable collection of items.

Example

use sqlvec::SqlVec;

let vec = SqlVec::new([1, 2, 3]);

pub fn into_inner(self) -> Vec<T>

Consumes the SqlVec, returning its internal vector.

This method allows you to take ownership of the underlying vector contained within the SqlVec. After calling into_inner, the SqlVec cannot be used anymore unless recreated.

Example

use sqlvec::SqlVec;

let sql_vec = SqlVec::new(vec![1, 2]);
let vec = sql_vec.into_inner();

assert_eq!(vec, vec![1, 2]);

pub fn inner(&self) -> &Vec<T>

Returns a borrowed reference to the internal vector.

Example

use sqlvec::SqlVec;

let sql_vec = SqlVec::new(vec![1, 2]);
let vec_ref = sql_vec.inner();


assert_eq!(vec_ref, &vec![1, 2]);

Trait Implementations

impl<T: Clone + ToString + FromStr> Clone for SqlVec<T>

fn clone(&self) -> SqlVec<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + ToString + FromStr> Debug for SqlVec<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: ToString + FromStr> Default for SqlVec<T>

fn default() -> Self

Unlike Vec, SqlVec does not require T to implement the Default trait.

Example

use sqlvec::SqlVec;

use std::str::FromStr;

struct MyType {
    value: i32,
}

impl ToString for MyType {
    fn to_string(&self) -> String {
        self.value.to_string()
    }
}

impl FromStr for MyType {
    type Err = std::num::ParseIntError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        s.parse::<i32>().map(|value| MyType { value })
    }
}

let default: SqlVec<MyType> = SqlVec::default();

impl<T: ToString + FromStr> FromIterator<T> for SqlVec<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: ToString + FromStr> FromSql for SqlVec<T>

fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self>

Converts SQLite value into Rust value.

impl FromStr for SqlVec<String>

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<T: PartialEq + ToString + FromStr> PartialEq for SqlVec<T>

fn eq(&self, other: &SqlVec<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: ToString + FromStr> ToSql for SqlVec<T>

fn to_sql(&self) -> Result<ToSqlOutput<'_>>

Converts Rust value to SQLite value

impl<T: ToString + FromStr> ToString for SqlVec<T>

fn to_string(&self) -> String

Converts the given value to a String.

impl<T: Eq + ToString + FromStr> Eq for SqlVec<T>

impl<T: ToString + FromStr> StructuralPartialEq for SqlVec<T>