open column families automatically, returns status

.gitignore

@@ -27,3 +27,4 @@ compile_commands.json
 CTestTestfile.cmake
 _deps
 
+*.db

cozo-rocks/build.rs

@@ -2,7 +2,7 @@ fn main() {
     cxx_build::bridge("src/lib.rs")
         .file("src/cozorocks.cc")
         .include("../rocksdb/include")
-        .include("src")
+        .include("include")
         .flag_if_supported("-std=c++17")
         .compile("cozo-rocks");
 
@@ -12,5 +12,5 @@ fn main() {
     println!("cargo:rustc-link-lib=bz2");
     println!("cargo:rerun-if-changed=src/main.rs");
     println!("cargo:rerun-if-changed=src/cozorocks.cc");
-    println!("cargo:rerun-if-changed=src/cozorocks.h");
+    println!("cargo:rerun-if-changed=include/cozorocks.h");
 }

cozo-rocks/include/cozorocks.h

@@ -161,19 +161,39 @@ struct DBBridge {
     }
 };
 
-inline std::vector <std::string> list_column_families(const OptionsBridge &options,
+inline std::unique_ptr <std::vector<std::string>> list_column_families(const OptionsBridge &options,
-                                                      const rust::Slice<const uint8_t> path) {
+                                                                       const rust::Slice<const uint8_t> path) {
-    std::vector <std::string> column_families;
+    auto column_families = std::make_unique < std::vector < std::string >> ();
     RDB::DB::ListColumnFamilies(options.inner,
                                 std::string(reinterpret_cast<const char *>(path.data()), path.size()),
-                                &column_families);
+                                &*column_families);
     return column_families;
 }
 
-inline std::unique_ptr <DBBridge> open_db(const OptionsBridge &options, const rust::Slice<const uint8_t> path) {
+inline std::unique_ptr <DBBridge> open_db(const OptionsBridge &options, const rust::Slice<const uint8_t> path, Status &status) {
+    auto old_column_families = std::vector<std::string>();
+    RDB::DB::ListColumnFamilies(options.inner,
+                                std::string(reinterpret_cast<const char *>(path.data()), path.size()),
+                                &old_column_families);
+    if (old_column_families.empty()) {
+        old_column_families.push_back(RDB::kDefaultColumnFamilyName);
+    }
+
+    std::vector <RDB::ColumnFamilyDescriptor> column_families;
+
+    for (auto el: old_column_families) {
+        column_families.push_back(RDB::ColumnFamilyDescriptor(
+                el, options.inner));
+    }
+
+    std::vector < RDB::ColumnFamilyHandle * > handles;
+
     RDB::DB *db_ptr;
     RDB::Status s = RDB::DB::Open(options.inner,
                                   std::string(reinterpret_cast<const char *>(path.data()), path.size()),
+                                  column_families,
+                                  &handles,
                                   &db_ptr);
+    write_status(std::move(s), status);
     return std::unique_ptr<DBBridge>(new DBBridge(db_ptr));
 }

cozo-rocks/src/cozorocks.cc

@@ -2,7 +2,7 @@
 // Created by Ziyang Hu on 2022/4/13.
 //
 
-#include "cozorocks.h"
+#include "../include/cozorocks.h"
 #include "cozo-rocks/src/lib.rs.h"
 
 void write_status_impl(Status &status, StatusCode code, StatusSubCode subcode, StatusSeverity severity) {

cozo-rocks/src/lib.rs

@@ -84,7 +84,8 @@ mod ffi {
         fn set_comparator(self: &OptionsBridge, name: &str, compare: fn(&[u8], &[u8]) -> i8);
 
         type DBBridge;
-        fn open_db(options: &OptionsBridge, path: &[u8]) -> UniquePtr<DBBridge>;
+        fn list_column_families(options: &OptionsBridge, path: &[u8]) -> UniquePtr<CxxVector<CxxString>>;
+        fn open_db(options: &OptionsBridge, path: &[u8], status: &mut Status) -> UniquePtr<DBBridge>;
         fn put(self: &DBBridge, options: &WriteOptionsBridge, key: &[u8], val: &[u8], status: &mut Status);
         fn get(self: &DBBridge, options: &ReadOptionsBridge, key: &[u8], status: &mut Status) -> UniquePtr<PinnableSliceBridge>;
     }
@@ -182,30 +183,45 @@ pub struct DB {
     default_write_options: WriteOptions,
 }
 
+fn get_path_bytes(path: &std::path::Path) -> &[u8] {
+    #[cfg(unix)]
+    {
+        use std::os::unix::ffi::OsStrExt;
+        path.as_os_str().as_bytes()
+    }
+
+    #[cfg(not(unix))]
+    { path.to_string_lossy().to_string().as_bytes() }
+}
+
 impl DB {
     #[inline]
-    pub fn open(options: Options, path: impl AsRef<std::path::Path>) -> Self {
+    pub fn list_column_families(options: &Options, path: impl AsRef<std::path::Path>) -> Vec<String> {
-        #[cfg(unix)]
+        let results = list_column_families(&options.bridge, get_path_bytes(path.as_ref()));
-        {
+        results.iter().map(|s| s.to_string_lossy().into_owned()).collect()
-            use std::os::unix::ffi::OsStrExt;
+    }
-            Self {
+
-                bridge: open_db(
+    #[inline]
-                    &options.bridge,
+    pub fn open(options: Options, path: impl AsRef<std::path::Path>) -> Result<Self, Status> {
-                    path.as_ref().as_os_str().as_bytes(),
+        let mut status = Status::default();
-                ),
+        let bridge = open_db(
+            &options.bridge,
+            get_path_bytes(path.as_ref()),
+            &mut status
+        );
+
+        if status.code == StatusCode::kOk {
+            Ok(Self {
+                bridge,
                 default_read_options: ReadOptions::default(),
                 default_write_options: WriteOptions::default(),
                 options,
-            }
+            })
-        }
+        } else {
-        #[cfg(not(unix))]
+            Err(status)
-        {
-            Self {
-                bridge: open_db(
-                    &options.bridge,
-                    path.as_ref().to_string_lossy().to_string().as_bytes())
-            }
         }
+
+
     }
 
     #[inline]

src/storage.rs

@@ -6,22 +6,6 @@ pub struct Storage {
     #[allow(dead_code)]
     path: String,
 }
-//
-// fn make_options() -> Options {
-//     let mut options = Options::default();
-//
-//     options.create_missing_column_families(true);
-//     options.create_if_missing(true);
-//     options.set_comparator("cozo_comparator_v1", cozo_comparator_v1);
-//     options
-// }
-
-// #[allow(dead_code)]
-// fn make_write_options(global: bool) -> WriteOptions {
-//     let mut options = WriteOptions::new();
-//     options.disable_wal(!global);
-//     options
-// }
 
 impl Storage {
     pub fn no_storage() -> Self {
@@ -79,13 +63,15 @@ mod tests {
     #[test]
     fn import() {
         use cozo_rocks::*;
+        let options = Options::default()
+            .increase_parallelism()
+            .optimize_level_style_compaction()
+            .set_create_if_missing(true)
+            .set_comparator("cozo_comparator_v1", cozo_comparator_v1);
+        println!("{:?}", DB::list_column_families(&options, "xxyyzz.db"));
 
-        let db = DB::open(Options::default()
+        let db = DB::open(options,
-                              .increase_parallelism()
+                          "xxyyzz.db").unwrap();
-                              .optimize_level_style_compaction()
-                              .set_create_if_missing(true)
-                              .set_comparator("cozo_comparator_v1", cozo_comparator_v1),
-                          "xxyyzz.db");
 
         let mut x = vec![];
         let mut builder = ByteArrayBuilder::new(&mut x);