reference.rs

use std::rc::Rc;
use rusqlite::{params, Connection, Statement};
use owning_ref::OwningHandle;

struct MyStatements<'a> {
    select_all: Statement<'a>,
    select_one: Statement<'a>
}

type MyStatementsOwned = OwningHandle<Rc<Connection>, Box<MyStatements<'static>>>;

impl<'a> MyStatements<'a> {
    fn new_owned(conn: Rc<Connection>) -> MyStatementsOwned {
        OwningHandle::try_new(conn, |conn| -> Result<_,()> {
            let (select_all, select_one) =  unsafe {
                ((*conn).prepare("SELECT * FROM data").unwrap(),
                 (*conn).prepare("SELECT 1").unwrap())
            };

            let tr = MyStatements {
                select_all,
                select_one,
            };

            Ok(Box::new(tr))
        }).unwrap()
    }
}

pub struct SqliteHelper {
    connection: Rc<Connection>,
    statements: MyStatementsOwned
}

impl SqliteHelper {

    fn new(db: &str) -> SqliteHelper {
        let conn = Rc::new(Connection::open(db).unwrap());
        SqliteHelper {
            statements: MyStatements::new_owned(conn.clone()),
            connection: conn,
        }
    }

    fn do_something(&mut self) {
        self.statements.select_one.execute(params![]).unwrap();
    }
}


fn main() {
    let mut helper = SqliteHelper::new("my_database.db");
    helper.do_something();
}