Skip to content

Commit 8866719

Browse files
SamarthPyatiSamarthPyati
committed
Remove Sqlite model.
1 parent 61df1f6 commit 8866719

5 files changed

Lines changed: 112 additions & 297 deletions

File tree

‎Cargo.lock‎

Lines changed: 0 additions & 47 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎Cargo.toml‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,5 @@ poppler-rs = "0.24.1"
99
rust-stemmers = "1.2.0"
1010
serde = { version = "1.0.219" , features = ["derive"] }
1111
serde_json = "1.0.140"
12-
sqlite = "0.30.3"
13-
sqlite3-sys = "0.14.0"
1412
tiny_http = "0.12.0"
1513
xml-rs = "0.8.26"

‎src/main.rs‎

Lines changed: 15 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,11 @@
11
use std:: {
2-
env::{self}, fs::{self, File}, io::{self, BufReader, BufWriter, Read}, path::Path, process::{exit, ExitCode}, str::{self},
3-
sync::{Arc, Mutex}, thread
2+
env::{self},
3+
fs::{self, File},
4+
io::{self, BufReader, BufWriter, Read},
5+
path::Path, process::{exit, ExitCode},
6+
str::{self},
7+
sync::{Arc, Mutex},
8+
thread
49
};
510

611
use xml::{self, reader::XmlEvent, EventReader};
@@ -219,7 +224,6 @@ fn check_index(index_path: &str) -> Result<(), ()> {
219224
}
220225

221226
const DEFAULT_INDEX_JSON_PATH: &str = "index.json";
222-
const DEFAULT_INDEX_SQLITE_DB_PATH: &str = "index.db";
223227

224228
/* Fetch the InMemory model from an index file */
225229
fn fetch_model(index_path: &str) -> Result<InMemoryModel, ()> {
@@ -245,13 +249,16 @@ fn usage(program: &String) {
245249
fn entry() -> Result<(), ()> {
246250
let mut args = env::args();
247251
let program = args.next().expect("path to program is provided");
252+
let cloned_args: Vec<String> = env::args().skip(1).collect::<Vec<String>>();
248253

249254
let mut subcommand = None;
250-
let mut use_sqlite_mode = false;
251255

252-
while let Some(arg) = args.next() {
256+
for arg in cloned_args {
253257
match arg.as_str() {
254-
"--sqlite" => use_sqlite_mode = true,
258+
"--sqlite" => {
259+
eprintln!("{}: 'SQLITE' mode is depracated. Remove '--sqlite' flag.", "ERROR".red().bold());
260+
exit(-1);
261+
}
255262
_ => {
256263
subcommand = Some(arg);
257264
break
@@ -266,7 +273,6 @@ fn entry() -> Result<(), ()> {
266273

267274
match subcommand.as_str() {
268275
"search" => {
269-
assert!(!use_sqlite_mode, "Sqlite mode is DEPRACATED.");
270276
let index_path = args.next().ok_or_else(|| {
271277
usage(&program);
272278
eprintln!("{}: Index file path must provided for {} subcommand.", "ERROR".bold().red(), subcommand.bold().bright_blue());
@@ -286,18 +292,11 @@ fn entry() -> Result<(), ()> {
286292
}
287293

288294
"check" => {
289-
if use_sqlite_mode {
290-
let index_path = args.next().unwrap_or(DEFAULT_INDEX_SQLITE_DB_PATH.to_string());
291-
let model = SqliteModel::open(Path::new(&index_path))?;
292-
println!("{info}: Database has {count} entries.", info = "INFO".cyan(), count = model.check().unwrap());
293-
} else {
294-
let index_path = args.next().unwrap_or(DEFAULT_INDEX_JSON_PATH.to_string());
295-
check_index(&index_path).unwrap();
296-
}
295+
let index_path = args.next().unwrap_or(DEFAULT_INDEX_JSON_PATH.to_string());
296+
check_index(&index_path).unwrap();
297297
}
298298

299299
"serve" => {
300-
assert!(!use_sqlite_mode, "SQLITE mode is DEPRACATED.");
301300
let dir_path = args.next().ok_or_else(|| {
302301
usage(&program);
303302
eprintln!("{}: No directory path is provided for {} subcommand.", "ERROR".bold().red(), subcommand.bold().bright_blue());

‎src/model.rs‎

Lines changed: 0 additions & 176 deletions
Original file line numberDiff line numberDiff line change
@@ -7,189 +7,13 @@ use serde::{Deserialize, Serialize};
77
use std::default::Default;
88
use super::lexer::*;
99

10-
use sqlite::{self};
11-
use colored::{Colorize};
12-
1310
pub trait Model {
1411
fn search_query(&self, query: &[char]) -> Result<Vec<(PathBuf, f32)>, ()>;
1512
fn add_document(&mut self, path: PathBuf, content: &[char], last_modified: SystemTime) -> Result<(), ()>;
1613
fn requires_reindexing(&mut self, path: &Path, last_modified: SystemTime) -> Result<bool, ()>;
1714
}
1815

19-
pub struct SqliteModel {
20-
connection: sqlite::Connection
21-
}
22-
23-
impl SqliteModel {
24-
pub fn execute(&self, statement: &str) -> Result<(), ()> {
25-
self.connection.execute(statement).map_err(|err| {
26-
eprintln!("{}: Failed to execute query {query} as {err}", "ERROR".bold().red(), query = statement.bright_blue(), err = err.to_string().red());
27-
})?;
28-
Ok(())
29-
}
30-
31-
pub fn begin(&self) -> Result<(), ()> {
32-
// TODO: Add error logging
33-
self.execute("BEGIN;")
34-
}
35-
36-
pub fn commit(&self) -> Result<(), ()> {
37-
// TODO: Add error logging
38-
self.execute("COMMIT;")
39-
}
40-
41-
pub fn open(path: &Path) -> Result<Self, ()> {
42-
let connection = sqlite::open(path).map_err(|err| {
43-
eprintln!("{}: Could not open sqlite database {path} as {err}", "ERROR".bold().red(), path = path.display().to_string().bright_blue(), err = err.to_string().red());
44-
})?;
45-
46-
let this = Self {connection};
47-
48-
// Table Documents (Contains path and term_count)
49-
this.execute("
50-
CREATE TABLE IF NOT EXISTS Documents (
51-
id INTEGER NOT NULL PRIMARY KEY,
52-
path TEXT,
53-
term_count INTEGER,
54-
UNIQUE(path)
55-
);
56-
")?;
57-
58-
// Table FreqTable (Contains map of term with its count refering to a document)
59-
this.execute("
60-
CREATE TABLE IF NOT EXISTS FreqTable (
61-
term TEXT,
62-
doc_id INTEGER,
63-
freq INTEGER,
64-
UNIQUE(term, doc_id),
65-
FOREIGN KEY(doc_id) REFERENCES Documents(id)
66-
);
67-
")?;
68-
69-
// Table GlobalTermFreq (Contains map of term with its frequency of occurence in entire document corpus)
70-
this.execute("
71-
CREATE TABLE IF NOT EXISTS GlobalTermFreq (
72-
term TEXT,
73-
freq INTEGER,
74-
UNIQUE(term)
75-
);
76-
")?;
77-
78-
Ok(this)
79-
}
80-
81-
pub fn check(&self) -> Result<u64, ()> {
82-
let count = {
83-
let query = "SELECT COUNT(*) as count FROM Documents";
84-
let log_err = |err: sqlite::Error| {
85-
eprintln!("{ERROR}: Could not execute query {query} as {err}", ERROR = "ERROR".bold().red(), err = err.to_string().red());
86-
};
87-
88-
let mut stmt = self.connection.prepare(query).map_err(log_err)?;
89-
match stmt.next().map_err(log_err)? {
90-
sqlite::State::Row => stmt.read::<i64, _>("count").map_err(log_err)?,
91-
sqlite::State::Done => 0,
92-
}
93-
};
94-
Ok(count as u64)
95-
}
96-
97-
}
98-
99-
impl Model for SqliteModel {
100-
fn search_query(&self, _query: &[char]) -> Result<Vec<(PathBuf, f32)>, ()> {
101-
todo!("SqliteModel::search_query()");
102-
}
103-
104-
fn requires_reindexing(&mut self, _path: &Path, _last_modified: SystemTime) -> Result<bool, ()> {
105-
Ok(true)
106-
}
107-
108-
109-
fn add_document(&mut self, path: PathBuf, content: &[char], _last_modified: SystemTime) -> Result<(), ()> {
110-
let terms = Lexer::new(content).collect::<Vec<_>>();
111-
// Populate Documents Table
112-
let doc_id = {
113-
let query = "INSERT INTO Documents (path, term_count) VALUES (:path, :count)";
114-
115-
let log_err = |err: sqlite::Error| {
116-
eprintln!("{ERROR}: Could not execute query {query} as {err}", ERROR = "ERROR".bold().red(), err = err.to_string().red());
117-
};
118-
119-
let mut stmt = self.connection.prepare(query).map_err(log_err)?;
120-
stmt.bind_iter::<_, (_, sqlite::Value)>([
121-
(":path", path.display().to_string().as_str().into()),
122-
(":count", (terms.len() as i64).into()),
123-
]).map_err(log_err)?;
124-
stmt.next().map_err(log_err)?;
125-
126-
unsafe {
127-
sqlite3_sys::sqlite3_last_insert_rowid(self.connection.as_raw())
128-
}
129-
};
130-
131-
let mut freq_table = FreqTable::new();
132-
133-
for term in &terms {
134-
freq_table.entry(term.to_owned()).and_modify(|x| *x += 1).or_insert(1);
135-
}
136-
137-
for (term, freq) in &freq_table {
138-
// Populate FreqTable
139-
{
140-
let query = "INSERT INTO FreqTable(doc_id, term, freq) VALUES (:doc_id, :term, :freq)";
141-
let log_err = |err: sqlite::Error| {
142-
eprintln!("{ERROR}: Could not execute query {query} as {err}", ERROR = "ERROR".bold().red(), err = err.to_string().red());
143-
};
144-
145-
let mut stmt = self.connection.prepare(query).map_err(log_err)?;
146-
stmt.bind_iter::<_, (_, sqlite::Value)>([
147-
(":doc_id", doc_id.into()),
148-
(":term", term.as_str().into()),
149-
(":freq", (*freq as i64).into()),
150-
]).map_err(log_err)?;
151-
stmt.next().map_err(log_err)?;
152-
}
153-
154-
// Populate GlobalTermFreq
155-
{
156-
let freq = {
157-
let query = "SELECT freq FROM GlobalTermFreq WHERE term = :term";
158-
let log_err = |err: sqlite::Error| {
159-
eprintln!("{ERROR}: Could not execute query {query} as {err}", ERROR = "ERROR".bold().red(), err = err.to_string().red());
160-
};
161-
162-
let mut stmt = self.connection.prepare(query).map_err(log_err)?;
163-
stmt.bind_iter::<_, (_, sqlite::Value)>([
164-
(":term", term.as_str().into()),
165-
]).map_err(log_err)?;
166-
match stmt.next().map_err(log_err)? {
167-
sqlite::State::Row => stmt.read::<i64, _>("freq").map_err(log_err)?,
168-
sqlite::State::Done => 0,
169-
}
170-
};
171-
172-
// TODO: Find better way to autoincrement the frequency
173-
let query = "INSERT OR REPLACE INTO GlobalTermFreq(term, freq) VALUES (:term, :freq)";
174-
let log_err = |err: sqlite::Error| {
175-
eprintln!("{ERROR}: Could not execute query {query} as {err}", ERROR = "ERROR".bold().red(), err = err.to_string().red());
176-
};
177-
178-
let mut stmt = self.connection.prepare(query).map_err(log_err)?;
179-
stmt.bind_iter::<_, (_, sqlite::Value)>([
180-
(":term", term.as_str().into()),
181-
(":freq", ((freq + 1) as i64).into()),
182-
]).map_err(log_err)?;
183-
stmt.next().map_err(log_err)?;
184-
}
185-
}
186-
187-
Ok(())
188-
}
189-
}
190-
19116
// ---- Associative types ----
192-
19317
/* Answers how frequently a term occurs in a single document.
19418
Map of term with its frequency of occurence single document. */
19519
pub type FreqTable = HashMap::<String, usize>;

0 commit comments

Comments
 (0)