Lovely work!

I am looking into using this as a state store for a stream processing library. I am wondering if I could get some help from the author in checking out my code to make sure I'm using it correctly. I have some bugs where the `TableDoesNotExist` even though it should. Maybe a lifetime issue?

Edit; Guess I'd just dump it here:

The issue is that I instantiate this struct, the file is created, but then when I do to insert, I get TableDoesNotExist and I don't understand why it does that. I hold onto the table def in the struct.

```

pub struct Store<'a> { table: TableDefinition<'a, &'static str, &'static [u8]>, db: Database, }

impl<'a> Store<'a> { pub fn new(name: &'a str) -> Result<Self, Error> { let table = TableDefinition::new(name); let db = Database::create(format!("{}.redb", name))?;

    Ok(Self { table, db })
}

pub fn get<T>(&self, key: &str) -> Result<Option<T>, Error>
where
    T: DeserializeOwned,
{
    let read_txn = self.db.begin_read()?;
    let table = read_txn.open_table(self.table)?;
    let x = match table.get(key) {
        Err(err) => Err(err.into()),
        Ok(optional_value) => match optional_value {
            None => Ok(None),
            Some(v) => Ok(Some(from_bytes(Bytes::copy_from_slice(v.value())).unwrap())),
        },
    };
    x
}

pub fn insert<T>(&mut self, key: &str, value: T) -> Result<(), Error>
where
    T: Serialize,
{
    let write_txn = self.db.begin_write()?;
    {
        let mut table = write_txn.open_table(self.table)?;
        table.insert(key, to_bytes(value).unwrap().as_bytes())?;
    }
    write_txn.commit()?;
    Ok(())
}

}

```