Initial commit of search

gkorland · gavrie · commit ba5ede9edf99 · 2019-09-04T09:32:40.000+03:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -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" }
diff --git a/src/error.rs b/src/error.rs
@@ -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)
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,18 +1,22 @@
 #[macro_use]
 extern crate redismodule;
 
+use redisearch_api;
 use redismodule::native_types::RedisType;
 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 redisjsonschema;
 
 use crate::index::Index;
-use crate::redisjson::{Error, Format, RedisJSON, SetOptions};
+use crate::redisjson::{Format, RedisJSON, SetOptions};
+use crate::error::{Error};
 
 static JSON_TYPE_ENCODING_VERSION: i32 = 2;
 static JSON_TYPE_NAME: &str = "ReJSON-RL";
@@ -34,6 +38,26 @@ static REDIS_JSON_TYPE: RedisType = RedisType::new(
     },
 );
 
+static JSON_SCHEMA_ENCODING_VERSION: i32 = 1;
+static JSON_SCHEMA_NAME: &str = "ReJSON-SCHEMA";
+
+static REDIS_JSON_SCHEMA_TYPE: RedisType = RedisType::new(
+    JSON_SCHEMA_NAME,
+    JSON_SCHEMA_ENCODING_VERSION,
+    raw::RedisModuleTypeMethods {
+        version: raw::REDISMODULE_TYPE_METHOD_VERSION as u64,
+
+        rdb_load: Some(redisjsonschema::json_schema_rdb_load),
+        rdb_save: Some(redisjsonschema::json_schema_rdb_save),
+        aof_rewrite: None, // TODO add support
+        free: Some(redisjsonschema::json_schema_free),
+
+        // Currently unused by Redis
+        mem_usage: None,
+        digest: None,
+    },
+);
+
 ///
 /// Backwards compatibility convertor for RedisJSON 1.x clients
 ///
@@ -697,6 +721,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())
 }
@@ -711,6 +739,7 @@ redis_module! {
     version: 1,
     data_types: [
         REDIS_JSON_TYPE,
+        REDIS_JSON_SCHEMA_TYPE
     ],
     commands: [
         ["json.del", json_del, "write"],
@@ -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"],
     ],
diff --git a/src/redisjson.rs b/src/redisjson.rs
@@ -5,7 +5,9 @@
 // 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 redismodule::raw;
@@ -14,50 +16,13 @@ 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,
diff --git a/src/redisjsonschema.rs b/src/redisjsonschema.rs
@@ -0,0 +1,37 @@
+use redismodule::raw;
+use std::os::raw::{c_int, c_void};
+use crate::error::Error;
+
+#[derive(Debug)]
+pub struct RedisJSONSchema {
+    data: String
+}
+
+impl RedisJSONSchema {
+    pub fn from_str(data: &str) -> Result<Self, Error> {
+        // let value = RedisJSON::parse_str(data, format)?;
+        Ok(Self {data: data.to_string()})
+    }
+}
+
+#[allow(non_snake_case, unused)]
+pub unsafe extern "C" fn json_schema_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)]
+#[no_mangle]
+pub unsafe extern "C" fn json_schema_free(value: *mut c_void) {
+    Box::from_raw(value as *mut RedisJSONSchema);
+}
+
+#[allow(non_snake_case, unused)]
+#[no_mangle]
+pub unsafe extern "C" fn json_schema_rdb_save(rdb: *mut raw::RedisModuleIO, value: *mut c_void) {
+    let schema = &*(value as *mut RedisJSONSchema);
+    raw::save_string(rdb, &schema.data.to_string());
+}
