Merge pull request #74 from RedBeardLab/2018_edition

2018 edition

Author: siscia

Cargo.lock

@@ -2,6 +2,7 @@
 name = "rediSQL"
 version = "1.0.3-rc02"
 authors = ["Simone Mosciatti <simone@redbeardlab.tech>"]
+edition = "2018"
 
 [lib]
 name = "redis_sql"

Cargo.toml

@@ -2,6 +2,7 @@
 name = "redisql_lib"
 version = "0.5.5-rc02"
 authors = ["Simone Mosciatti <mweb.sim@gmail.com>"]
+edition = "2018"
 
 [build-dependencies]
 bindgen = "0.47.1"

redisql_lib/Cargo.toml

@@ -1,7 +1,7 @@
-use sqlite::ffi;
-use sqlite::SQLiteConnection;
-use sqlite::StatementTrait;
-use sqlite::{Cursor, RawConnection, SQLite3Error, SQLiteOK};
+use crate::sqlite::ffi;
+use crate::sqlite::SQLiteConnection;
+use crate::sqlite::StatementTrait;
+use crate::sqlite::{Cursor, RawConnection, SQLite3Error, SQLiteOK};
 
 use std::ffi::{CStr, CString};
 use std::fmt;

redisql_lib/src/community_statement.rs

@@ -2,7 +2,6 @@
 
 #[macro_use]
 extern crate log;
-extern crate serde;
 
 pub mod community_statement;
 pub mod redis;

redisql_lib/src/lib.rs

@@ -1,6 +1,4 @@
-extern crate fnv;
-
-use self::fnv::FnvHashMap;
+use fnv::FnvHashMap;
 use std;
 use std::cell::RefCell;
 use std::clone::Clone;
@@ -16,19 +14,21 @@ use std::str;
 use std::sync::mpsc::{Receiver, RecvError, Sender};
 use std::sync::{Arc, Mutex, MutexGuard, RwLock};
 
-pub use redis_type as rm;
-use redis_type::{BlockedClient, Context, OpenKey, ReplyWithError};
+pub use crate::redis_type as rm;
+use crate::redis_type::{
+    BlockedClient, Context, OpenKey, ReplyWithError,
+};
 
-use redisql_error as err;
-use redisql_error::RediSQLError;
+use crate::redisql_error as err;
+use crate::redisql_error::RediSQLError;
 
-use sqlite::StatementTrait;
+use crate::sqlite::StatementTrait;
 
-use community_statement::MultiStatement;
+use crate::community_statement::MultiStatement;
 
-use sqlite as sql;
+use crate::sqlite as sql;
 
-use statistics::STATISTICS;
+use crate::statistics::STATISTICS;
 
 #[derive(Clone)]
 pub struct ReplicationBook {
@@ -37,16 +37,16 @@ pub struct ReplicationBook {
 }
 
 pub trait StatementCache<'a> {
-    fn new(&Arc<Mutex<sql::RawConnection>>) -> Self;
-    fn is_statement_present(&self, &str) -> bool;
+    fn new(db: &Arc<Mutex<sql::RawConnection>>) -> Self;
+    fn is_statement_present(&self, identifier: &str) -> bool;
     fn insert_new_statement(
         &mut self,
         identifier: &str,
         statement: &str,
     ) -> Result<QueryResult, RediSQLError>;
     fn delete_statement(
         &mut self,
-        &str,
+        identifier: &str,
     ) -> Result<QueryResult, RediSQLError>;
     fn update_statement(
         &mut self,
@@ -55,13 +55,13 @@ pub trait StatementCache<'a> {
     ) -> Result<QueryResult, RediSQLError>;
     fn exec_statement(
         &self,
-        &str,
-        &[&str],
+        identifier: &str,
+        args: &[&str],
     ) -> Result<QueryResult, RediSQLError>;
     fn query_statement(
         &self,
-        &str,
-        &[&str],
+        identifier: &str,
+        args: &[&str],
     ) -> Result<QueryResult, RediSQLError>;
 }
 

redisql_lib/src/redis.rs

@@ -2,8 +2,8 @@ use std::error;
 use std::error::Error;
 use std::fmt;
 
-use redis;
-use sqlite as sql;
+use crate::redis;
+use crate::sqlite as sql;
 
 pub trait RediSQLErrorTrait: fmt::Display + error::Error {}
 

redisql_lib/src/redisql_error.rs

@@ -7,11 +7,11 @@ use std::os::raw::c_char;
 use std::ptr;
 use std::sync::{Arc, Mutex};
 
-use redis::QueryResult;
+use crate::redis::QueryResult;
 
-use redisql_error as err;
+use crate::redisql_error as err;
 
-use community_statement::Statement;
+use crate::community_statement::Statement;
 
 #[allow(dead_code)]
 #[allow(non_snake_case)]

redisql_lib/src/sqlite.rs

@@ -1,7 +1,10 @@
-use redis_type::ffi as rffi;
-use redis_type::{CallReply, Context};
-use sqlite::ffi;
-use sqlite::{SQLite3Error, SQLiteConnection, SQLITE_TRANSIENT};
+use crate::redis_type::ffi as rffi;
+use crate::redis_type::{CallReply, Context};
+use crate::sqlite::ffi;
+use crate::sqlite::{
+    SQLite3Error, SQLiteConnection, SQLITE_TRANSIENT,
+};
+
 use std::cell::RefCell;
 use std::collections::VecDeque;
 use std::ffi::{CStr, CString};

redisql_lib/src/virtual_tables.rs

@@ -17,6 +17,9 @@ use sync_engine::Replicate;
 
 use redisql_lib::statistics::STATISTICS;
 
+const REDISQL_VERSION: Option<&'static str> =
+    option_env!("CARGO_PKG_VERSION");
+
 extern "C" fn reply_exec(
     ctx: *mut r::rm::ffi::RedisModuleCtx,
     _argv: *mut *mut r::rm::ffi::RedisModuleString,
@@ -854,7 +857,7 @@ pub extern "C" fn CreateDB(
                                     vtab::register_modules(&rc)
                                 }) {
                                 Err(e) => e.reply(&context),
-                                Ok(mut vtab_context) => {
+                                Ok(vtab_context) => {
                                     let (tx, rx) = channel();
                                     let db = r::DBKey::new_from_arc(
                                         tx,
@@ -1096,3 +1099,16 @@ pub extern "C" fn GetStatistics(
 
     r::rm::ffi::REDISMODULE_OK
 }
+
+#[allow(non_snake_case)]
+pub extern "C" fn RediSQLVersion(
+    ctx: *mut r::rm::ffi::RedisModuleCtx,
+    _argv: *mut *mut r::rm::ffi::RedisModuleString,
+    _argc: ::std::os::raw::c_int,
+) -> i32 {
+    let context = r::rm::Context::new(ctx);
+    let version = REDISQL_VERSION.unwrap_or("unknown");
+    r::rm::ReplyWithStringBuffer(&context, version.as_bytes());
+
+    r::rm::ffi::REDISMODULE_OK
+}