feat: implement a search engine to search into the data

Cargo.toml

@@ -48,6 +48,7 @@ reqwest = {version = "0.11.13", features = ["blocking"]}
 select = "0.5.0"
 serde_json = "1.0.89"
 serde = { version = "1.0.147", features = ["derive"] }
+serde_repr = "0.1.9"
 
 [dev-dependencies]
 pretty_assertions = "1.3.0"

src/rust/merged_ultraslim.rs

@@ -1,42 +1,81 @@
 use std::collections::HashMap;
 
+use serde::Deserialize;
+use serde_repr::Deserialize_repr;
+
+#[derive(Deserialize_repr, PartialEq)]
+#[repr(u8)]
+pub enum DataType {
+    MySQL = 1,
+    MariaDB = 2,
+}
+
+#[derive(Deserialize)]
 pub struct Link {
     pub a: String,
-    pub u: i8,
-    pub t: i8,
+    pub u: usize,
+    pub t: DataType,
 }
 
+#[derive(Deserialize)]
 pub struct Variable {
-    pub n: String,
-    pub t: i8,
+    pub n: Option<String>,
+    pub t: Option<usize>,
     pub d: Option<bool>,
     pub a: Vec<Link>,
 }
 
+#[derive(Deserialize)]
 pub struct MergedUltraSlim {
-    pub vars: Vec<Variable>,
-    pub version: i8,
+    pub vars: HashMap<String, Variable>,
+    pub version: usize,
     pub urls: Vec<String>,
-    pub types: HashMap<i8, String>,
-    pub var_types: HashMap<i8, String>,
+    pub types: HashMap<usize, String>,
+    #[serde(rename = "varTypes")]
+    pub var_types: HashMap<usize, String>,
+}
+
+#[derive(PartialEq)]
+pub enum SearchType {
+    Any = -1,
+    MySQL = 1,
+    MariaDB = 2,
 }
-/*
+
+#[derive(Debug)]
+pub struct SearchError {}
+
 impl MergedUltraSlim {
-    pub fn new() -> MergedUltraSlim {
-        MergedUltraSlim {
-            vars: vec![],
-            version: 1,
-            urls: vec![],
-            types: HashMap::new(),
-            var_types: HashMap::new()
+    pub fn get_by_name(
+        &self,
+        variable_name: &str,
+        search_type: SearchType,
+    ) -> Result<String, SearchError> {
+        let kb_entry = self.get_variable(variable_name);
+        match kb_entry {
+            Ok(entry) => {
+                let found = entry.a.iter().find(|link| {
+                    (search_type == SearchType::Any)
+                        | (search_type == SearchType::MySQL && link.t == DataType::MySQL)
+                        | (search_type == SearchType::MariaDB && link.t == DataType::MariaDB)
+                });
+                match found {
+                    Some(link) => Ok(format!(
+                        "{}#{}",
+                        self.urls.get(link.u).expect("Url to exist in table"),
+                        link.a,
+                    )),
+                    None => Err(SearchError {}),
+                }
+            }
+            Err(err) => Err(err),
+        }
+    }
+
+    pub fn get_variable(&self, variable_name: &str) -> Result<&Variable, SearchError> {
+        match self.vars.get(variable_name) {
+            Some(entry) => Ok(entry),
+            None => Err(SearchError {}),
         }
     }
 }
-pub const data: MergedUltraSlim = MergedUltraSlim {
-    version: 1,
-    vars: [Variable; 0] = [],
-    urls: [String; 0] = [],
-    types: HashMap::new(),
-    var_types: HashMap::new()
-};
-*/

src/rust/search.rs

@@ -1,5 +1,147 @@
-pub const ANY: i8 = -1;
-pub const MYSQL: i8 = 1;
-pub const MARIADB: i8 = 2;
+use std::env;
+use std::fs;
+use std::sync::Mutex;
 
-pub static IS_LOADED: bool = false;
+use crate::merged_ultraslim::MergedUltraSlim;
+
+static DATA: Mutex<Option<MergedUltraSlim>> = Mutex::new(None);
+
+pub fn load_data() {
+    let mut lock = DATA.try_lock();
+    if let Ok(ref mut data_mutex) = lock {
+        if data_mutex.is_some() {
+            return;
+        }
+        let source_dir = env::current_dir().unwrap();
+        const FILE_NAME: &str = "merged-ultraslim.json";
+        let file_contents =
+            fs::read_to_string(source_dir.to_str().unwrap().to_owned() + "/dist/" + FILE_NAME)
+                .expect("Should have been able to read the data file");
+        data_mutex.replace(
+            serde_json::from_str(&file_contents).expect("JSON data could not be decoded !"),
+        );
+    } else {
+        eprintln!("Could not lock the mutex");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::merged_ultraslim::SearchType;
+
+    // Note this useful idiom: importing names from outer (for mod tests) scope.
+    use super::*;
+
+    #[test]
+    fn test_load_data() {
+        load_data();
+        let data = DATA.lock().unwrap().take().unwrap();
+
+        assert_eq!(
+            true,
+            data.get_by_name("adadadadad", SearchType::MariaDB).is_err()
+        );
+        assert_eq!(
+            true,
+            data.get_by_name("adadadadad", SearchType::MySQL).is_err()
+        );
+        assert_eq!(
+            true,
+            data.get_by_name("adadadadad", SearchType::Any).is_err()
+        );
+
+        assert_eq!(
+            "https://dev.mysql.com/doc/refman/5.7/en/mysql-cluster-options-variables.html#option_mysqld_ndb-log-orig",
+            data.get_by_name("ndb_log_orig", SearchType::MySQL).unwrap().as_str()
+        );
+        assert_eq!(
+            "https://dev.mysql.com/doc/refman/5.7/en/mysql-cluster-options-variables.html#option_mysqld_ndb-log-orig",
+            data.get_by_name("ndb_log_orig", SearchType::Any).unwrap().as_str()
+        );
+        assert_eq!(
+            true,
+            data.get_by_name("ndb_log_orig", SearchType::MariaDB)
+                .is_err()
+        );
+
+        assert_eq!(
+            "https://dev.mysql.com/doc/refman/8.0/en/replication-options.html#sysvar_server_id",
+            data.get_by_name("server_id", SearchType::MySQL)
+                .unwrap()
+                .as_str()
+        );
+        assert_eq!(
+            "https://mariadb.com/kb/en/library/documentation/gtid/#server_id",
+            data.get_by_name("server_id", SearchType::MariaDB)
+                .unwrap()
+                .as_str()
+        );
+        assert_eq!(
+            "https://mariadb.com/kb/en/library/documentation/gtid/#server_id",
+            data.get_by_name("server_id", SearchType::Any)
+                .unwrap()
+                .as_str()
+        );
+    }
+}
+/*
+
+     * get the type of the variable
+     *
+     * @param string $name Name of variable
+     * @return string
+     * @throws KBException
+
+    public static function getVariableType(string $name): string
+    {
+        self::loadData();
+        $kbEntry = self::getVariable($name);
+        if (isset($kbEntry->t)) {
+            return Search::$data->varTypes->{$kbEntry->t};
+        } else {
+            throw new KBException($name . ' does have a known type !');
+        }
+    }
+
+
+     * Return the list of static variables
+     *
+     * @return array<int,string>
+
+    public static function getStaticVariables(): array
+    {
+        return self::getVariablesWithDynamic(false);
+    }
+
+
+     * Return the list of dynamic variables
+     *
+     * @return array<int,string>
+
+    public static function getDynamicVariables(): array
+    {
+        return self::getVariablesWithDynamic(true);
+    }
+
+
+     * Return the list of variables having dynamic = $dynamic
+     *
+     * @param bool $dynamic dynamic=true/dynamic=false
+     * @return array<int,string>
+
+    public static function getVariablesWithDynamic(bool $dynamic): array
+    {
+        self::loadData();
+        $staticVars = [];
+        foreach (Search::$data->vars as $name => $var) {
+            if (isset($var->d)) {
+                if ($var->d === $dynamic) {
+                    $staticVars[] = $name;
+                }
+            }
+        }
+        return $staticVars;
+    }
+
+}
+*/