Merge pull request #19 from mleduque/n1ql-query

Allow n1ql queries

Author: Dushistov

couchbase-lite-core-sys/couchbase-lite-core

@@ -82,6 +82,15 @@ impl AsFlSlice for FlSliceOwner {
     }
 }
 
+impl AsFlSlice for FLSliceResult {
+    fn as_flslice(&self) -> FLSlice {
+        FLSlice {
+            buf: self.buf,
+            size: self.size,
+        }
+    }
+}
+
 #[inline]
 pub(crate) unsafe fn fl_slice_to_str_unchecked<'a>(s: FLSlice) -> &'a str {
     let bytes: &[u8] = slice::from_raw_parts(s.buf as *const u8, s.size);

couchbase-lite/src/fl_slice.rs

@@ -204,6 +204,10 @@ impl Database {
     pub fn query(&self, query_json: &str) -> Result<Query> {
         Query::new(self, query_json)
     }
+    /// Compiles a query from an expression given as N1QL.
+    pub fn n1ql_query(&self, query: &str) -> Result<Query> {
+        Query::new_n1ql(self, query)
+    }
 
     /// Creates an enumerator ordered by docID.
     pub fn enumerate_all_docs(&self, flags: DocEnumeratorFlags) -> Result<DocEnumerator> {

couchbase-lite/src/lib.rs

@@ -1,15 +1,16 @@
 use crate::{
     error::{c4error_init, Error},
     ffi::{
-        c4query_free, c4query_new, c4query_run, c4queryenum_free, c4queryenum_next,
-        kC4DefaultQueryOptions, C4Query, C4QueryEnumerator, FLArrayIterator_GetCount,
-        FLArrayIterator_GetValueAt,
+        c4query_free, c4query_new, c4query_new2, c4query_run, c4query_setParameters,
+        c4queryenum_free, c4queryenum_next, kC4DefaultQueryOptions, kC4N1QLQuery, C4Query,
+        C4QueryEnumerator, FLArrayIterator_GetCount, FLArrayIterator_GetValueAt,
     },
     fl_slice::{fl_slice_empty, AsFlSlice},
     value::{FromValueRef, ValueRef},
     Database, Result,
 };
 use fallible_streaming_iterator::FallibleStreamingIterator;
+use serde::Serialize;
 use std::ptr::NonNull;
 
 pub struct Query<'db> {
@@ -39,6 +40,36 @@ impl Query<'_> {
             .ok_or_else(|| c4err.into())
     }
 
+    pub(crate) fn new_n1ql<'a, 'b>(db: &'a Database, query_n1ql: &'b str) -> Result<Query<'a>> {
+        let mut c4err = c4error_init();
+        let mut out_error_pos: std::os::raw::c_int = -1;
+        let query = unsafe {
+            c4query_new2(
+                db.inner.0.as_ptr(),
+                kC4N1QLQuery,
+                query_n1ql.as_bytes().as_flslice(),
+                &mut out_error_pos,
+                &mut c4err,
+            )
+        };
+
+        NonNull::new(query)
+            .map(|inner| Query { _db: db, inner })
+            .ok_or_else(|| c4err.into())
+    }
+
+    pub fn set_parameters<T>(&self, parameters: &T) -> Result<()>
+    where
+        T: Serialize,
+    {
+        let param_string = serde_json::to_string(parameters)?;
+        let param_slice = param_string.as_bytes().as_flslice();
+        unsafe {
+            c4query_setParameters(self.inner.as_ptr(), param_slice);
+        }
+        Ok(())
+    }
+
     pub fn run(&self) -> Result<Enumerator> {
         let mut c4err = c4error_init();
         let it = unsafe {

couchbase-lite/src/query.rs

@@ -499,3 +499,93 @@ fn test_like_performance() {
     }
     tmp_dir.close().expect("Can not close tmp_dir");
 }
+
+#[test]
+fn test_n1ql_query() {
+    let _ = env_logger::try_init();
+    let tmp_dir = tempdir().expect("Can not create tmp directory");
+    println!("we create tempdir at {}", tmp_dir.path().display());
+    let db_path = tmp_dir.path().join("a.cblite2");
+    {
+        let mut db = Database::open(&db_path, DatabaseConfig::default()).unwrap();
+        let mut trans = db.transaction().unwrap();
+        for i in 0..10_000 {
+            let foo = Foo {
+                i,
+                s: format!("Hello {}", i),
+            };
+            let mut doc = Document::new(&foo).unwrap();
+            trans.save(&mut doc).unwrap();
+        }
+        trans.commit().unwrap();
+
+        let query = db.n1ql_query("SELECT s WHERE s LIKE '%555'").unwrap();
+        let expected = vec![
+            "Hello 1555",
+            "Hello 2555",
+            "Hello 3555",
+            "Hello 4555",
+            "Hello 555",
+            "Hello 5555",
+            "Hello 6555",
+            "Hello 7555",
+            "Hello 8555",
+            "Hello 9555",
+        ];
+
+        let mut iter = query.run().unwrap();
+        let mut query_ret = Vec::with_capacity(10);
+        while let Some(item) = iter.next().unwrap() {
+            let val = item.get_raw_checked(0).unwrap();
+            let val = val.as_str().unwrap();
+            query_ret.push(val.to_string());
+        }
+        query_ret.sort();
+
+        assert_eq!(expected, query_ret);
+    }
+    tmp_dir.close().expect("Can not close tmp_dir");
+}
+
+#[test]
+fn test_n1ql_query_with_parameter() {
+    let _ = env_logger::try_init();
+    let tmp_dir = tempdir().expect("Can not create tmp directory");
+    println!("we create tempdir at {}", tmp_dir.path().display());
+    let db_path = tmp_dir.path().join("a.cblite2");
+    {
+        let mut db = Database::open(&db_path, DatabaseConfig::default()).unwrap();
+        let mut trans = db.transaction().unwrap();
+        for i in 0..10_000 {
+            let foo = Foo {
+                i,
+                s: format!("Hello {}", i),
+            };
+            let mut doc = Document::new(&foo).unwrap();
+            trans.save(&mut doc).unwrap();
+        }
+        trans.commit().unwrap();
+
+        let query = db
+            .n1ql_query("SELECT s WHERE s LIKE $pattern ORDER BY s LIMIT 2 OFFSET 1")
+            .unwrap();
+        query
+            .set_parameters(&serde_json::json!({
+                "pattern": "%555",
+            }))
+            .unwrap();
+        let expected = vec!["Hello 2555", "Hello 3555"];
+
+        let mut iter = query.run().unwrap();
+        let mut query_ret = Vec::with_capacity(10);
+        while let Some(item) = iter.next().unwrap() {
+            let val = item.get_raw_checked(0).unwrap();
+            let val = val.as_str().unwrap();
+            query_ret.push(val.to_string());
+        }
+        query_ret.sort();
+
+        assert_eq!(expected, query_ret);
+    }
+    tmp_dir.close().expect("Can not close tmp_dir");
+}