MeiliSearch/meilisearch-http/src/data.rs

130 lines
3.5 KiB
Rust
Raw Normal View History

2019-10-31 15:00:36 +01:00
use std::collections::HashMap;
use std::ops::Deref;
use std::sync::Arc;
use chrono::{DateTime, Utc};
use heed::types::{SerdeBincode, Str};
2019-11-20 17:28:46 +01:00
use log::error;
use meilisearch_core::{Database, MainT, UpdateT, Error as MError, MResult};
2019-10-31 15:00:36 +01:00
use sysinfo::Pid;
use crate::option::Opt;
use crate::routes::index::index_update_callback;
2019-11-20 17:28:46 +01:00
const LAST_UPDATE_KEY: &str = "last-update";
2019-10-31 15:00:36 +01:00
type SerdeDatetime = SerdeBincode<DateTime<Utc>>;
#[derive(Clone)]
pub struct Data {
inner: Arc<DataInner>,
}
impl Deref for Data {
type Target = DataInner;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
#[derive(Clone)]
pub struct DataInner {
pub db: Arc<Database>,
pub db_path: String,
pub api_key: Option<String>,
2019-10-31 15:00:36 +01:00
pub server_pid: Pid,
}
impl DataInner {
pub fn is_indexing(&self, reader: &heed::RoTxn<UpdateT>, index: &str) -> MResult<Option<bool>> {
2019-10-31 15:00:36 +01:00
match self.db.open_index(&index) {
Some(index) => index.current_update_id(&reader).map(|u| Some(u.is_some())),
None => Ok(None),
}
}
pub fn last_update(&self, reader: &heed::RoTxn<MainT>) -> MResult<Option<DateTime<Utc>>> {
2019-10-31 15:00:36 +01:00
match self
.db
.common_store()
.get::<_, Str, SerdeDatetime>(reader, LAST_UPDATE_KEY)?
2019-10-31 15:00:36 +01:00
{
Some(datetime) => Ok(Some(datetime)),
None => Ok(None),
}
}
pub fn set_last_update(&self, writer: &mut heed::RwTxn<MainT>) -> MResult<()> {
2019-10-31 15:00:36 +01:00
self.db
.common_store()
.put::<_, Str, SerdeDatetime>(writer, LAST_UPDATE_KEY, &Utc::now())
2019-10-31 15:00:36 +01:00
.map_err(Into::into)
}
pub fn compute_stats(&self, writer: &mut heed::RwTxn<MainT>, index_uid: &str) -> MResult<()> {
2019-11-19 16:15:49 +01:00
let index = match self.db.open_index(&index_uid) {
2019-10-31 15:00:36 +01:00
Some(index) => index,
None => {
2019-11-19 16:15:49 +01:00
error!("Impossible to retrieve index {}", index_uid);
2019-10-31 15:00:36 +01:00
return Ok(());
}
};
let schema = match index.main.schema(&writer)? {
Some(schema) => schema,
None => return Ok(()),
};
let all_documents_fields = index
.documents_fields_counts
.all_documents_fields_counts(&writer)?;
// count fields frequencies
let mut fields_frequency = HashMap::<_, usize>::new();
for result in all_documents_fields {
let (_, attr, _) = result?;
*fields_frequency.entry(attr).or_default() += 1;
}
// convert attributes to their names
let frequency: HashMap<_, _> = fields_frequency
.into_iter()
.map(|(a, c)| (schema.attribute_name(a).to_owned(), c))
.collect();
2019-11-20 11:24:08 +01:00
index
.main
2019-11-20 17:28:46 +01:00
.put_fields_frequency(writer, &frequency)
2019-11-20 11:24:08 +01:00
.map_err(MError::Zlmdb)
2019-10-31 15:00:36 +01:00
}
}
impl Data {
pub fn new(opt: Opt) -> Data {
let db_path = opt.db_path.clone();
let api_key = opt.api_key.clone();
2019-10-31 15:00:36 +01:00
let server_pid = sysinfo::get_current_pid().unwrap();
let db = Arc::new(Database::open_or_create(opt.db_path.clone()).unwrap());
2019-10-31 15:00:36 +01:00
let inner_data = DataInner {
db: db.clone(),
db_path,
api_key,
2019-10-31 15:00:36 +01:00
server_pid,
};
let data = Data {
inner: Arc::new(inner_data),
};
let callback_context = data.clone();
2019-11-19 16:15:49 +01:00
db.set_update_callback(Box::new(move |index_uid, status| {
index_update_callback(&index_uid, &callback_context, status);
}));
2019-10-31 15:00:36 +01:00
data
}
}