add REDISQL.STATISTICS function

Author: siscia

redisql_lib/src/statistics.rs

@@ -196,4 +196,133 @@ impl Statistics {
     pub fn copy_err(&self) {
         STATISTICS.copy_err.fetch_add(1, Ordering::Relaxed);
     }
+    pub fn values(&self) -> Vec<(&'static str, usize)> {
+        let mut stats: Vec<(&'static str, usize)> = Vec::new();
+        stats.push((
+            "CREATE_DB",
+            self.create_db.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "CREATE_DB OK",
+            self.create_db_ok.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "CREATE_DB ERR",
+            self.create_db_err.load(Ordering::Relaxed),
+        ));
+        stats.push(("EXEC", self.exec.load(Ordering::Relaxed)));
+        stats.push(("EXEC OK", self.exec_ok.load(Ordering::Relaxed)));
+        stats.push((
+            "EXEC ERR",
+            self.exec_err.load(Ordering::Relaxed),
+        ));
+
+        stats.push(("QUERY", self.query.load(Ordering::Relaxed)));
+        stats.push((
+            "QUERY OK",
+            self.query_ok.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "QUERY ERR",
+            self.query_err.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "QUERY.INTO",
+            self.query_into.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "QUERY.INTO OK",
+            self.query_into_ok.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "QUERY.INTO ERR",
+            self.query_into_err.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "CREATE_STATEMENT",
+            self.create_statement.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "CREATE_STATEMENT OK",
+            self.create_statement_ok.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "CREATE_STATEMENT ERR",
+            self.create_statement_err.load(Ordering::Relaxed),
+        ));
+
+        stats.push((
+            "EXEC_STATEMENT",
+            self.exec_statement.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "EXEC_STATEMENT OK",
+            self.exec_statement_ok.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "EXEC_STATEMENT ERR",
+            self.exec_statement_err.load(Ordering::Relaxed),
+        ));
+
+        stats.push((
+            "UPDATE_STATEMENT",
+            self.update_statement.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "UPDATE_STATEMENT OK",
+            self.update_statement_ok.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "UPDATE_STATEMENT ERR",
+            self.update_statement_err.load(Ordering::Relaxed),
+        ));
+
+        stats.push((
+            "DELETE_STATEMENT",
+            self.delete_statement.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "DELETE_STATEMENT OK",
+            self.delete_statement_ok.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "DELETE_STATEMENT ERR",
+            self.delete_statement_err.load(Ordering::Relaxed),
+        ));
+
+        stats.push((
+            "QUERY_STATEMENT",
+            self.query_statement.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "QUERY_STATEMENT OK",
+            self.query_statement_ok.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "QUERY_STATEMENT ERR",
+            self.query_statement_err.load(Ordering::Relaxed),
+        ));
+
+        stats.push((
+            "QUERY_STATEMENT.INTO",
+            self.query_statement_into.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "QUERY_STATEMENT.INTO OK",
+            self.query_statement_into_ok.load(Ordering::Relaxed),
+        ));
+        stats.push((
+            "QUERY_STATEMENT.INTO ERR",
+            self.query_statement_into_err.load(Ordering::Relaxed),
+        ));
+
+        stats.push(("COPY", self.copy.load(Ordering::Relaxed)));
+        stats.push(("COPY OK", self.copy_ok.load(Ordering::Relaxed)));
+        stats.push((
+            "COPY ERR",
+            self.copy_err.load(Ordering::Relaxed),
+        ));
+
+        return stats;
+    }
 }

src/commands.rs

@@ -1,4 +1,5 @@
 use std::ffi::{CStr, CString};
+use std::os::raw::c_long;
 use std::sync::mpsc::channel;
 use std::thread;
 
@@ -802,6 +803,7 @@ pub extern "C" fn CreateDB(
                                     r::rm::ffi::REDISMODULE_OK => {
                                         let ok =
                                             r::QueryResult::OK {};
+                                        STATISTICS.create_db_ok();
                                         ReplicateVerbatim(&context);
                                         ok.reply(&context)
                                     }
@@ -969,3 +971,33 @@ pub extern "C" fn MakeCopy(
         Err(_) => r::rm::ffi::REDISMODULE_OK,
     }
 }
+
+#[allow(non_snake_case)]
+pub extern "C" fn GetStatistics(
+    ctx: *mut r::rm::ffi::RedisModuleCtx,
+    argv: *mut *mut r::rm::ffi::RedisModuleString,
+    argc: ::std::os::raw::c_int,
+) -> i32 {
+    let (context, _argvector) = r::create_argument(ctx, argv, argc);
+    let data = STATISTICS.values();
+
+    let len = data.len() as c_long;
+    unsafe {
+        r::rm::ffi::RedisModule_ReplyWithArray.unwrap()(
+            context.as_ptr(),
+            len,
+        );
+    }
+    for statics in data {
+        unsafe {
+            r::rm::ffi::RedisModule_ReplyWithArray.unwrap()(
+                context.as_ptr(),
+                2,
+            );
+        }
+        r::rm::ReplyWithStringBuffer(&context, statics.0.as_bytes());
+        r::rm::ReplyWithLongLong(&context, statics.1 as i64);
+    }
+
+    r::rm::ffi::REDISMODULE_OK
+}

src/lib.rs

@@ -34,8 +34,8 @@ use engine_pro::{register, WriteAOF};
 
 use commands::{
     CreateDB, CreateStatement, DeleteStatement, Exec, ExecStatement,
-    MakeCopy, Query, QueryInto, QueryStatement, QueryStatementInto,
-    UpdateStatement,
+    GetStatistics, MakeCopy, Query, QueryInto, QueryStatement,
+    QueryStatementInto, UpdateStatement,
 };
 
 unsafe extern "C" fn rdb_save(
@@ -311,6 +311,16 @@ pub extern "C" fn RedisModule_OnLoad(
         Err(e) => return e,
     }
 
+    match register_function(
+        &ctx,
+        "REDISQL.STATISTICS",
+        "readonly",
+        GetStatistics,
+    ) {
+        Ok(()) => (),
+        Err(e) => return e,
+    }
+
     #[cfg(feature = "pro")]
     match register(ctx) {
         Ok(()) => (),