Merge branch 'redisearch_type_methods'

Author: gavrie

.circleci/config.yml

@@ -15,7 +15,7 @@ jobs:
           command: |
              sudo apt-get install -y software-properties-common
              sudo add-apt-repository -y ppa:chris-lea/redis-server
-             sudo apt-get install -y clang python-pip redis-server
+             sudo apt-get install -y clang llvm cmake python-pip redis-server
 
       - run:
           name: Version information

Cargo.lock

@@ -8,8 +8,9 @@ edition = "2018"
 crate-type = ["cdylib"]
 
 [dependencies]
-bson = "0.13.0"
+bson = "0.13"
 serde_json = "1.0"
 libc = "0.2"
 jsonpath_lib = { git="https://github.com/gkorland/jsonpath.git", branch="reaplce_with_ownership_parser" }
 redismodule = { git="https://github.com/redislabsmodules/redismodule-rs.git", branch="master" }
+redisearch_api = { git = "https://github.com/RediSearch/redisearch-api-rs.git", branch="master" }

Cargo.toml

@@ -0,0 +1,38 @@
+use jsonpath_lib::JsonPathError;
+
+#[derive(Debug)]
+pub struct Error {
+    pub msg: String,
+}
+
+impl From<String> for Error {
+    fn from(e: String) -> Self {
+        Error { msg: e }
+    }
+}
+
+impl From<&str> for Error {
+    fn from(e: &str) -> Self {
+        Error { msg: e.to_string() }
+    }
+}
+
+impl From<serde_json::Error> for Error {
+    fn from(e: serde_json::Error) -> Self {
+        Error { msg: e.to_string() }
+    }
+}
+
+impl From<JsonPathError> for Error {
+    fn from(e: JsonPathError) -> Self {
+        Error {
+            msg: format!("{:?}", e),
+        }
+    }
+}
+
+impl From<Error> for redismodule::RedisError {
+    fn from(e: Error) -> Self {
+        redismodule::RedisError::String(e.msg)
+    }
+}

src/error.rs

@@ -2,31 +2,50 @@
 extern crate redismodule;
 
 use redismodule::native_types::RedisType;
+use redismodule::raw as rawmod;
+use redismodule::raw::RedisModuleTypeMethods;
 use redismodule::{Context, NextArg, RedisError, RedisResult, RedisValue, REDIS_OK};
 use serde_json::{Number, Value};
 use std::{i64, usize};
 
 mod backward;
+mod error;
 mod index;
 mod nodevisitor;
 mod redisjson;
+mod schema;
 
+use crate::error::Error;
 use crate::index::Index;
-use crate::redisjson::{Error, Format, RedisJSON, SetOptions};
-
-static JSON_TYPE_ENCODING_VERSION: i32 = 2;
-static JSON_TYPE_NAME: &str = "ReJSON-RL";
+use crate::redisjson::{Format, RedisJSON, SetOptions};
 
 static REDIS_JSON_TYPE: RedisType = RedisType::new(
-    JSON_TYPE_NAME,
-    JSON_TYPE_ENCODING_VERSION,
-    raw::RedisModuleTypeMethods {
-        version: raw::REDISMODULE_TYPE_METHOD_VERSION as u64,
+    "ReJSON-RL",
+    2,
+    RedisModuleTypeMethods {
+        version: redismodule::TYPE_METHOD_VERSION,
 
-        rdb_load: Some(redisjson::json_rdb_load),
-        rdb_save: Some(redisjson::json_rdb_save),
+        rdb_load: Some(redisjson::type_methods::rdb_load),
+        rdb_save: Some(redisjson::type_methods::rdb_save),
         aof_rewrite: None, // TODO add support
-        free: Some(redisjson::json_free),
+        free: Some(redisjson::type_methods::free),
+
+        // Currently unused by Redis
+        mem_usage: None,
+        digest: None,
+    },
+);
+
+static REDIS_JSON_SCHEMA_TYPE: RedisType = RedisType::new(
+    "ReJSON-SC",
+    1,
+    RedisModuleTypeMethods {
+        version: redismodule::TYPE_METHOD_VERSION,
+
+        rdb_load: Some(schema::type_methods::rdb_load),
+        rdb_save: Some(schema::type_methods::rdb_save),
+        aof_rewrite: None, // TODO add support
+        free: Some(schema::type_methods::free),
 
         // Currently unused by Redis
         mem_usage: None,
@@ -697,6 +716,10 @@ fn json_len<F: Fn(&RedisJSON, &String) -> Result<usize, Error>>(
     Ok(length)
 }
 
+fn json_createindex(ctx: &Context, args: Vec<String>) -> RedisResult {
+    Err("Command was not implemented".into())
+}
+
 fn json_cache_info(_ctx: &Context, _args: Vec<String>) -> RedisResult {
     Err("Command was not implemented".into())
 }
@@ -706,12 +729,18 @@ fn json_cache_init(_ctx: &Context, _args: Vec<String>) -> RedisResult {
 }
 //////////////////////////////////////////////////////
 
+pub extern "C" fn init(raw_ctx: *mut rawmod::RedisModuleCtx) -> c_int {
+    redisearch_api::init(raw_ctx)
+}
+
 redis_module! {
     name: "redisjson",
     version: 1,
     data_types: [
         REDIS_JSON_TYPE,
+        REDIS_JSON_SCHEMA_TYPE
     ],
+    init: init,
     commands: [
         ["json.del", json_del, "write"],
         ["json.get", json_get, ""],
@@ -734,6 +763,7 @@ redis_module! {
         ["json.debug", json_debug, ""],
         ["json.forget", json_del, "write"],
         ["json.resp", json_resp, ""],
+        ["json.createindex", json_createindex, "write"],
         ["json._cacheinfo", json_cache_info, ""],
         ["json._cacheinit", json_cache_init, "write"],
     ],

src/lib.rs

@@ -5,65 +5,29 @@
 // It can be operated on (e.g. INCR) and serialized back to JSON.
 
 use crate::backward;
+use crate::error::Error;
 use crate::nodevisitor::NodeVisitorImpl;
+
 use bson::decode_document;
-use jsonpath_lib::{JsonPathError, SelectorMut};
+use jsonpath_lib::SelectorMut;
 use redismodule::raw;
-use serde_json::{Map, Value};
+use serde_json::Value;
 use std::io::Cursor;
 use std::mem;
 use std::os::raw::{c_int, c_void};
 
-#[derive(Debug)]
-pub struct Error {
-    msg: String,
-}
-
 #[derive(Debug, PartialEq)]
 pub enum SetOptions {
     NotExists,
     AlreadyExists,
     None,
 }
 
-impl From<String> for Error {
-    fn from(e: String) -> Self {
-        Error { msg: e }
-    }
-}
-
-impl From<&str> for Error {
-    fn from(e: &str) -> Self {
-        Error { msg: e.to_string() }
-    }
-}
-
-impl From<serde_json::Error> for Error {
-    fn from(e: serde_json::Error) -> Self {
-        Error { msg: e.to_string() }
-    }
-}
-
-impl From<JsonPathError> for Error {
-    fn from(e: JsonPathError) -> Self {
-        Error {
-            msg: format!("{:?}", e),
-        }
-    }
-}
-
-impl From<Error> for redismodule::RedisError {
-    fn from(e: Error) -> Self {
-        redismodule::RedisError::String(e.msg)
-    }
-}
-
 #[derive(Debug, PartialEq)]
 pub enum Format {
     JSON,
     BSON,
 }
-
 impl Format {
     pub fn from_str(s: &str) -> Result<Format, Error> {
         match s {
@@ -362,27 +326,29 @@ impl RedisJSON {
     }
 }
 
-#[allow(non_snake_case, unused)]
-pub unsafe extern "C" fn json_rdb_load(rdb: *mut raw::RedisModuleIO, encver: c_int) -> *mut c_void {
-    let json = match encver {
-        0 => RedisJSON {
-            data: backward::json_rdb_load(rdb),
-        },
-        2 => RedisJSON::from_str(&raw::load_string(rdb), Format::JSON).unwrap(),
-        _ => panic!("Can't load old RedisJSON RDB"),
-    };
-    Box::into_raw(Box::new(json)) as *mut c_void
-}
+pub mod type_methods {
+    use super::*;
+
+    #[allow(non_snake_case, unused)]
+    pub unsafe extern "C" fn rdb_load(rdb: *mut raw::RedisModuleIO, encver: c_int) -> *mut c_void {
+        let json = match encver {
+            0 => RedisJSON {
+                data: backward::json_rdb_load(rdb),
+            },
+            2 => RedisJSON::from_str(&raw::load_string(rdb), Format::JSON).unwrap(),
+            _ => panic!("Can't load old RedisJSON RDB"),
+        };
+        Box::into_raw(Box::new(json)) as *mut c_void
+    }
 
-#[allow(non_snake_case, unused)]
-#[no_mangle]
-pub unsafe extern "C" fn json_free(value: *mut c_void) {
-    Box::from_raw(value as *mut RedisJSON);
-}
+    #[allow(non_snake_case, unused)]
+    pub unsafe extern "C" fn free(value: *mut c_void) {
+        Box::from_raw(value as *mut RedisJSON);
+    }
 
-#[allow(non_snake_case, unused)]
-#[no_mangle]
-pub unsafe extern "C" fn json_rdb_save(rdb: *mut raw::RedisModuleIO, value: *mut c_void) {
-    let json = &*(value as *mut RedisJSON);
-    raw::save_string(rdb, &json.data.to_string());
+    #[allow(non_snake_case, unused)]
+    pub unsafe extern "C" fn rdb_save(rdb: *mut raw::RedisModuleIO, value: *mut c_void) {
+        let json = &*(value as *mut RedisJSON);
+        raw::save_string(rdb, &json.data.to_string());
+    }
 }

src/redisjson.rs

@@ -0,0 +1,54 @@
+use crate::error::Error;
+use redisearch_api::Index;
+use redismodule::raw;
+use std::os::raw::{c_int, c_void};
+
+pub struct RedisJSONSchema {
+    index: Index,
+}
+
+impl RedisJSONSchema {
+    pub fn new(name: &str) -> RedisJSONSchema {
+        RedisJSONSchema {
+            index: Index::create(name),
+        }
+    }
+
+    pub fn from_str(data: &str) -> Result<Self, Error> {
+        // let value = RedisJSON::parse_str(data, format)?;
+        Ok(Self {
+            // TODO better handle RDB read
+            index: Index::create(data.to_string().as_str()),
+        })
+    }
+
+    pub fn add_index(&mut self, path: &str) -> Result<(), Error> {
+        self.index.create_field(path);
+        Ok(())
+    }
+}
+
+pub mod type_methods {
+    use super::*;
+
+    #[allow(non_snake_case, unused)]
+    pub unsafe extern "C" fn rdb_load(rdb: *mut raw::RedisModuleIO, encver: c_int) -> *mut c_void {
+        if encver < 2 {
+            panic!("Can't load old RedisJSONSchema RDB"); // TODO add support for backward
+        }
+        let json = RedisJSONSchema::from_str(&raw::load_string(rdb)).unwrap();
+        Box::into_raw(Box::new(json)) as *mut c_void
+    }
+
+    #[allow(non_snake_case, unused)]
+    pub unsafe extern "C" fn free(value: *mut c_void) {
+        Box::from_raw(value as *mut RedisJSONSchema);
+    }
+
+    #[allow(non_snake_case, unused)]
+    pub unsafe extern "C" fn rdb_save(rdb: *mut raw::RedisModuleIO, value: *mut c_void) {
+        let schema = &*(value as *mut RedisJSONSchema);
+        // TODO implement RDB write
+        // raw::save_string(rdb, &schema.schema.to_string());
+    }
+}