unobtanium 3.0.0

Opinioated Web search engine library with crawler and viewer companion.
Documentation 
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

use rusqlite::Connection;

use std::path::Path;

use crate::database::Database;
use crate::database::DatabaseError;
use crate::database::DatabaseOpeningError;
use crate::database::DatabaseTransaction;

pub struct CrawlerDatabase {
	base_db: Database,
}

pub struct CrawlerDatabaseTransaction<'a> {
	pub base_transaction: DatabaseTransaction<'a>
}

impl CrawlerDatabase {
	/// Initalize from a base database.
	pub fn initalize_from_base(db: Database) -> Result<Self, DatabaseOpeningError> {
		let crawler_db = Self {
			base_db: db,
		};
		crawler_db.check_crawler_schema()?;
		crawler_db.initalize_crawler_database()
			.map_err(|e| e.while_initlizing(crawler_db.base_db.path()))?;
		Ok(crawler_db)
	}

	pub fn open_writable(path: impl AsRef<Path>) -> Result<Self, DatabaseOpeningError> {
		let database = Database::open_writable(&path)?;
		Self::initalize_from_base(database)
	}

	pub fn open_read_only(path: impl AsRef<Path>) -> Result<Self, DatabaseOpeningError> {
		let database = Self {
			base_db: Database::open_read_only(&path)?
		};
		database.check_crawler_schema()?;
		Ok(database)
	}


	/// Grants access read only to the  base database.
	pub fn base(&self) -> &Database {
		&self.base_db
	}

	/// Grants mutable access to the uderlying base database.
	pub fn base_mut(&mut self) -> &mut Database {
		&mut self.base_db
	}

	/// Starts a database transaction and returns a handle for it.
	pub fn start_transaction(
		&mut self
	) -> Result<CrawlerDatabaseTransaction, DatabaseError> {
		return Ok(CrawlerDatabaseTransaction{
			base_transaction: self.base_db.start_transaction()?,
		})
	}

	/// Returns a handle for the database connection.
	pub fn connection(&self) -> &Connection {
		&self.base_db.connection
	}

}

impl<'a> CrawlerDatabaseTransaction<'a> {

	/// Returns a handle for the database connection.
	pub fn connection(&self) -> &Connection {
		&self.base_transaction.transaction
	}

	/// Commit changes made within this transaction to the database.
	pub fn commit(self) -> Result<(), DatabaseError> {
		return self.base_transaction.commit();
	}
}