Resolve "Implement DB Integration"

Closes #35 (closed)

src/main.rs

 // SPDX-FileCopyrightText: 2024 Phil Höfer <phil@suma-ev.de>
 // SPDX-License-Identifier: AGPL-3.0-only
 
+use core::str;
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::{self, BufRead, BufReader};
@@ -8,6 +9,7 @@ use std::error::Error;
 use std::str::FromStr;
 use std::fs;
 
+use predictors::basic_set::SetPredictor;
 use toml::Table;
 
 use csv::ReaderBuilder;
@@ -19,10 +21,13 @@ mod predictors;
 use predictors::{basic_markov,basic_set, Predictor};
 use predictors::basic_markov::MarkovChain;
 
+use postgres::{Client, NoTls};
+
 
 fn main() -> Result<(), io::Error> {
 
-    let config_toml = read_config("config.toml").unwrap().parse::<Table>().unwrap();
+    let mut last_update = std::time::SystemTime::now();
+    let config_toml = read_config("data/config.toml").or(read_config("config.toml")).unwrap().parse::<Table>().unwrap();
     let mut config = HashMap::new();
     for (key, value) in config_toml {
         match value {
@@ -38,10 +43,12 @@ fn main() -> Result<(), io::Error> {
         }
     }
 
-    let markov_chain = basic_set::from_file_path_and_config(
+
+    let mut markov_chain = basic_set::from_file_path_and_config(
         vec!["../../data/data.csv","data/data.csv","data.csv","data_full.csv"],config.clone())
                 .unwrap_or(basic_set::SetPredictor::new());
 
+    markov_chain = read_from_db(config.clone(), markov_chain);
 
     // let term_frequency_threshold = match config.get("term_frequency_threshold") {
     //     Some(toml::Value::Integer(n)) if *n >= 0 => *n as usize,
@@ -96,6 +103,12 @@ fn main() -> Result<(), io::Error> {
                 //println!("Query: {}, Prediction:{}", query, prediction);
                 let response = Response::from_string(prediction);
                 request.respond(response);
+                let now = std::time::SystemTime::now();
+                let elapsed = now.duration_since(last_update).expect("Time went backwards");
+                if elapsed >= std::time::Duration::from_secs(24 * 60 * 60) {
+                    markov_chain = read_from_db(config.clone(), markov_chain);
+                    last_update = now;
+                }
             },
             Err(e) => {
                 //println!("Error: {}",e);
@@ -106,6 +119,40 @@ fn main() -> Result<(), io::Error> {
     Ok(())
 }
 
+
+fn read_from_db(config: HashMap<String, String>, mut predictor: SetPredictor) -> SetPredictor {
+    let default_password = &String::from("");
+    let db_password = config.get("db_password").unwrap_or(default_password);
+    let mut client = Client::connect(format!("host=localhost user=metager password={} dbname=postgres",db_password).as_str(), NoTls);
+
+
+
+    match client {
+        Ok(mut c) => {
+            let mut count = 0;
+            match c.query("SELECT query FROM public.logs_partitioned ORDER BY time DESC LIMIT 5000", &[]) {
+                Ok(rows) => {
+                    for row in rows {
+                        let query: &str = row.get(0);
+                        predictor.update(query);
+                        count += 1;
+                    }
+                    println!("{} queries read from DB", count);
+                    predictor
+                },
+                Err(e) => {
+                    predictor
+                }
+            }
+        },
+        Err(e) => {
+            predictor
+        }
+        
+    }
+
+} 
+
 fn read_config(file_path: &str) -> Result<String, io::Error> {
     fs::read_to_string(file_path)
 }