1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#![cfg(feature = "sqlite")]
use super::sqlite::SqlTable;
use crate::data::Integer;
use crate::prelude::*;
use crate::{data::Numeric, table::general::Bucket, HashTables};
use fnv::FnvHashSet;
use std::ops::{Deref, DerefMut};
use std::path::Path;
pub struct SqlTableMem<N, K>
where
N: Numeric,
K: Integer,
{
sql_table: SqlTable<N, K>,
}
impl<N, K> SqlTableMem<N, K>
where
N: Numeric,
K: Integer,
{
pub fn to_db<P: AsRef<Path>>(&mut self, db_path: P) -> Result<()> {
let mut new_con = rusqlite::Connection::open(db_path)?;
{
let backup = rusqlite::backup::Backup::new(&self.conn, &mut new_con)?;
backup.step(-1)?;
}
self.conn = new_con;
self.committed.set(true);
Ok(())
}
}
impl<N, K> Deref for SqlTableMem<N, K>
where
N: Numeric,
K: Integer,
{
type Target = SqlTable<N, K>;
fn deref(&self) -> &SqlTable<N, K> {
&self.sql_table
}
}
impl<N, K> DerefMut for SqlTableMem<N, K>
where
N: Numeric,
K: Integer,
{
fn deref_mut(&mut self) -> &mut SqlTable<N, K> {
&mut self.sql_table
}
}
impl<N, K> HashTables<N, K> for SqlTableMem<N, K>
where
N: Numeric,
K: Integer,
{
fn new(n_hash_tables: usize, only_index_storage: bool, _db_path: &str) -> Result<Box<Self>> {
let conn = rusqlite::Connection::open_in_memory()?;
let sql_table = SqlTable::init_from_conn(n_hash_tables, only_index_storage, conn)?;
Ok(Box::new(SqlTableMem { sql_table }))
}
fn put(&mut self, hash: Vec<K>, d: &[N], hash_table: usize) -> Result<u32> {
self.sql_table.put(hash, d, hash_table)
}
fn delete(&mut self, hash: &[K], d: &[N], hash_table: usize) -> Result<()> {
self.sql_table.delete(hash, d, hash_table)
}
fn query_bucket(&self, hash: &[K], hash_table: usize) -> Result<Bucket> {
self.sql_table.query_bucket(hash, hash_table)
}
fn idx_to_datapoint(&self, idx: u32) -> Result<&Vec<N>> {
self.sql_table.idx_to_datapoint(idx)
}
fn describe(&self) -> Result<String> {
self.sql_table.describe()
}
fn get_unique_hash_int(&self) -> FnvHashSet<i32> {
self.sql_table.get_unique_hash_int()
}
}