Add wrapper for GetColumnFamilyMetaData (#188)

librocksdb_sys/crocksdb/c.cc

@@ -131,6 +131,9 @@ using rocksdb::DecodeFixed32;
 using rocksdb::DecodeFixed64;
 using rocksdb::PutFixed64;
 using rocksdb::VectorRepFactory;
+using rocksdb::ColumnFamilyMetaData;
+using rocksdb::LevelMetaData;
+using rocksdb::SstFileMetaData;
 
 using std::shared_ptr;
 
@@ -193,6 +196,16 @@ struct crocksdb_compactionfiltercontext_t {
   CompactionFilter::Context rep;
 };
 
+struct crocksdb_column_family_meta_data_t {
+  ColumnFamilyMetaData rep;
+};
+struct crocksdb_level_meta_data_t {
+  LevelMetaData rep;
+};
+struct crocksdb_sst_file_meta_data_t {
+  SstFileMetaData rep;
+};
+
 struct crocksdb_compactionfilter_t : public CompactionFilter {
   void* state_;
   void (*destructor_)(void*);
@@ -4024,4 +4037,48 @@ uint64_t crocksdb_set_external_sst_file_global_seq_no(
   return pre_seq_no;
 }
 
+void crocksdb_get_column_family_meta_data(
+    crocksdb_t* db,
+    crocksdb_column_family_handle_t* cf,
+    crocksdb_column_family_meta_data_t* meta) {
+  db->rep->GetColumnFamilyMetaData(cf->rep, &meta->rep);
+}
+
+crocksdb_column_family_meta_data_t* crocksdb_column_family_meta_data_create() {
+  return new crocksdb_column_family_meta_data_t();
+}
+
+void crocksdb_column_family_meta_data_destroy(
+    crocksdb_column_family_meta_data_t* meta) {
+  delete meta;
+}
+
+size_t crocksdb_column_family_meta_data_level_count(
+    const crocksdb_column_family_meta_data_t* meta) {
+  return meta->rep.levels.size();
+}
+
+const crocksdb_level_meta_data_t* crocksdb_column_family_meta_data_level_data(
+    const crocksdb_column_family_meta_data_t* meta, size_t n) {
+  return reinterpret_cast<const crocksdb_level_meta_data_t*>(&meta->rep.levels[n]);
+}
+
+size_t crocksdb_level_meta_data_file_count(
+    const crocksdb_level_meta_data_t* meta) {
+  return meta->rep.files.size();
+}
+
+const crocksdb_sst_file_meta_data_t* crocksdb_level_meta_data_file_data(
+    const crocksdb_level_meta_data_t* meta, size_t n) {
+  return reinterpret_cast<const crocksdb_sst_file_meta_data_t*>(&meta->rep.files[n]);
+}
+
+size_t crocksdb_sst_file_meta_data_size(const crocksdb_sst_file_meta_data_t* meta) {
+  return meta->rep.size;
+}
+
+const char* crocksdb_sst_file_meta_data_name(const crocksdb_sst_file_meta_data_t* meta) {
+  return meta->rep.name.data();
+}
+
 }  // end extern "C"

librocksdb_sys/crocksdb/crocksdb/c.h

@@ -132,6 +132,9 @@ typedef struct crocksdb_externalfileingestioninfo_t
     crocksdb_externalfileingestioninfo_t;
 typedef struct crocksdb_eventlistener_t crocksdb_eventlistener_t;
 typedef struct crocksdb_keyversions_t crocksdb_keyversions_t;
+typedef struct crocksdb_column_family_meta_data_t crocksdb_column_family_meta_data_t;
+typedef struct crocksdb_level_meta_data_t crocksdb_level_meta_data_t;
+typedef struct crocksdb_sst_file_meta_data_t crocksdb_sst_file_meta_data_t;
 
 typedef enum crocksdb_table_property_t {
   kDataSize = 1,
@@ -1604,6 +1607,29 @@ crocksdb_set_external_sst_file_global_seq_no(
   uint64_t seq_no,
   char **errptr);
 
+/* ColumnFamilyMetaData */
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_get_column_family_meta_data(crocksdb_t* db,
+                                     crocksdb_column_family_handle_t* cf,
+                                     crocksdb_column_family_meta_data_t*);
+extern C_ROCKSDB_LIBRARY_API crocksdb_column_family_meta_data_t*
+crocksdb_column_family_meta_data_create();
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_column_family_meta_data_destroy(crocksdb_column_family_meta_data_t*);
+extern C_ROCKSDB_LIBRARY_API size_t
+crocksdb_column_family_meta_data_level_count(const crocksdb_column_family_meta_data_t*);
+extern C_ROCKSDB_LIBRARY_API const crocksdb_level_meta_data_t*
+crocksdb_column_family_meta_data_level_data(const crocksdb_column_family_meta_data_t*,
+                                            size_t n);
+extern C_ROCKSDB_LIBRARY_API size_t
+crocksdb_level_meta_data_file_count(const crocksdb_level_meta_data_t*);
+extern C_ROCKSDB_LIBRARY_API const crocksdb_sst_file_meta_data_t*
+crocksdb_level_meta_data_file_data(const crocksdb_level_meta_data_t*, size_t n);
+extern C_ROCKSDB_LIBRARY_API size_t
+crocksdb_sst_file_meta_data_size(const crocksdb_sst_file_meta_data_t*);
+extern C_ROCKSDB_LIBRARY_API const char*
+crocksdb_sst_file_meta_data_name(const crocksdb_sst_file_meta_data_t*);
+
 #ifdef __cplusplus
 }  /* end extern "C" */
 #endif

librocksdb_sys/src/lib.rs

@@ -62,6 +62,9 @@ pub enum DBEventListener {}
 pub enum DBKeyVersions {}
 pub enum DBEnv {}
 pub enum DBSequentialFile {}
+pub enum DBColumnFamilyMetaData {}
+pub enum DBLevelMetaData {}
+pub enum DBSstFileMetaData {}
 
 pub fn new_bloom_filter(bits: c_int) -> *mut DBFilterPolicy {
     unsafe { crocksdb_filterpolicy_create_bloom(bits) }
@@ -1538,6 +1541,31 @@ extern "C" {
         seq_no: u64,
         err: *mut *mut c_char,
     ) -> u64;
+
+    pub fn crocksdb_get_column_family_meta_data(
+        db: *mut DBInstance,
+        cf: *mut DBCFHandle,
+        meta: *mut DBColumnFamilyMetaData,
+    );
+
+    pub fn crocksdb_column_family_meta_data_create() -> *mut DBColumnFamilyMetaData;
+    pub fn crocksdb_column_family_meta_data_destroy(meta: *mut DBColumnFamilyMetaData);
+    pub fn crocksdb_column_family_meta_data_level_count(
+        meta: *const DBColumnFamilyMetaData,
+    ) -> size_t;
+    pub fn crocksdb_column_family_meta_data_level_data(
+        meta: *const DBColumnFamilyMetaData,
+        n: size_t,
+    ) -> *const DBLevelMetaData;
+
+    pub fn crocksdb_level_meta_data_file_count(meta: *const DBLevelMetaData) -> size_t;
+    pub fn crocksdb_level_meta_data_file_data(
+        meta: *const DBLevelMetaData,
+        n: size_t,
+    ) -> *const DBSstFileMetaData;
+
+    pub fn crocksdb_sst_file_meta_data_size(meta: *const DBSstFileMetaData) -> size_t;
+    pub fn crocksdb_sst_file_meta_data_name(meta: *const DBSstFileMetaData) -> *const c_char;
 }
 
 #[cfg(test)]

src/lib.rs

@@ -31,6 +31,7 @@ mod table_properties_collector;
 mod table_properties_collector_factory;
 mod event_listener;
 mod table_filter;
+mod metadata;
 
 pub use compaction_filter::CompactionFilter;
 pub use event_listener::{CompactionJobInfo, EventListener, FlushJobInfo, IngestionInfo};
@@ -38,6 +39,7 @@ pub use librocksdb_sys::{self as crocksdb_ffi, new_bloom_filter, CompactionPrior
                          DBCompactionStyle, DBCompressionType, DBEntryType, DBInfoLogLevel,
                          DBRecoveryMode, DBStatisticsHistogramType, DBStatisticsTickerType};
 pub use merge_operator::MergeOperands;
+pub use metadata::{ColumnFamilyMetaData, LevelMetaData, SstFileMetaData};
 pub use rocksdb::{set_external_sst_file_global_seq_no, BackupEngine, CFHandle, DBIterator,
                   DBVector, Env, ExternalSstFileInfo, Kv, Range, SeekKey, SequentialFile,
                   SstFileWriter, Writable, WriteBatch, DB};

src/metadata.rs

+// Copyright 2018 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crocksdb_ffi::{self, DBColumnFamilyMetaData, DBLevelMetaData, DBSstFileMetaData};
+use std::ffi::CStr;
+
+pub struct ColumnFamilyMetaData {
+    inner: *mut DBColumnFamilyMetaData,
+}
+
+impl ColumnFamilyMetaData {
+    pub fn from_ptr(inner: *mut DBColumnFamilyMetaData) -> ColumnFamilyMetaData {
+        ColumnFamilyMetaData { inner: inner }
+    }
+
+    pub fn get_levels(&self) -> Vec<LevelMetaData> {
+        let mut levels = Vec::new();
+        unsafe {
+            let n = crocksdb_ffi::crocksdb_column_family_meta_data_level_count(self.inner);
+            for i in 0..n {
+                let data = crocksdb_ffi::crocksdb_column_family_meta_data_level_data(self.inner, i);
+                levels.push(LevelMetaData { inner: data });
+            }
+        }
+        levels
+    }
+}
+
+impl Drop for ColumnFamilyMetaData {
+    fn drop(&mut self) {
+        unsafe {
+            crocksdb_ffi::crocksdb_column_family_meta_data_destroy(self.inner);
+        }
+    }
+}
+
+pub struct LevelMetaData {
+    inner: *const DBLevelMetaData,
+}
+
+impl LevelMetaData {
+    pub fn get_files(&self) -> Vec<SstFileMetaData> {
+        let mut files = Vec::new();
+        unsafe {
+            let n = crocksdb_ffi::crocksdb_level_meta_data_file_count(self.inner);
+            for i in 0..n {
+                let data = crocksdb_ffi::crocksdb_level_meta_data_file_data(self.inner, i);
+                files.push(SstFileMetaData { inner: data });
+            }
+        }
+        files
+    }
+}
+
+pub struct SstFileMetaData {
+    inner: *const DBSstFileMetaData,
+}
+
+impl SstFileMetaData {
+    pub fn get_size(&self) -> usize {
+        unsafe { crocksdb_ffi::crocksdb_sst_file_meta_data_size(self.inner) }
+    }
+
+    pub fn get_name(&self) -> String {
+        unsafe {
+            let ptr = crocksdb_ffi::crocksdb_sst_file_meta_data_name(self.inner);
+            CStr::from_ptr(ptr).to_string_lossy().into_owned()
+        }
+    }
+}

src/rocksdb.rs

@@ -16,6 +16,7 @@ use crocksdb_ffi::{self, DBBackupEngine, DBCFHandle, DBCompressionType, DBEnv, D
                    DBPinnableSlice, DBSequentialFile, DBStatisticsHistogramType,
                    DBStatisticsTickerType, DBWriteBatch};
 use libc::{self, c_int, c_void, size_t};
+use metadata::ColumnFamilyMetaData;
 use rocksdb_options::{ColumnFamilyDescriptor, ColumnFamilyOptions, CompactOptions, DBOptions,
                       EnvOptions, FlushOptions, HistogramData, IngestExternalFileOptions,
                       ReadOptions, RestoreOptions, UnsafeSnap, WriteOptions};
@@ -1370,6 +1371,14 @@ impl DB {
             Ok(key_versions)
         }
     }
+
+    pub fn get_column_family_meta_data(&self, cf: &CFHandle) -> ColumnFamilyMetaData {
+        unsafe {
+            let inner = crocksdb_ffi::crocksdb_column_family_meta_data_create();
+            crocksdb_ffi::crocksdb_get_column_family_meta_data(self.inner, cf.inner, inner);
+            ColumnFamilyMetaData::from_ptr(inner)
+        }
+    }
 }
 
 impl Writable for DB {

tests/test.rs

 extern crate byteorder;
 extern crate crc;
+extern crate rand;
 extern crate rocksdb;
 extern crate tempdir;
-extern crate rand;
 
 mod test_iterator;
 mod test_multithreaded;
@@ -20,3 +20,4 @@ mod test_delete_range;
 mod test_delete_files_in_range;
 mod test_read_only;
 mod test_rate_limiter;
+mod test_metadata;

tests/test_metadata.rs

+// Copyright 2018 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use rocksdb::{ColumnFamilyOptions, DBOptions, Writable, DB};
+use tempdir::TempDir;
+
+#[test]
+fn test_metadata() {
+    let path = TempDir::new("_rust_rocksdb_test_metadata").unwrap();
+    let mut opts = DBOptions::new();
+    opts.create_if_missing(true);
+    let mut cf_opts = ColumnFamilyOptions::new();
+    cf_opts.set_disable_auto_compactions(true);
+    let db = DB::open_cf(
+        opts,
+        path.path().to_str().unwrap(),
+        vec![("default", cf_opts)],
+    ).unwrap();
+    let cf_handle = db.cf_handle("default").unwrap();
+
+    let num_files = 5;
+    for i in 0..num_files {
+        db.put(&[i], &[i]).unwrap();
+        db.flush(true).unwrap();
+    }
+
+    let cf_meta = db.get_column_family_meta_data(cf_handle);
+    let cf_levels = cf_meta.get_levels();
+    assert_eq!(cf_levels.len(), 7);
+    for (i, cf_level) in cf_levels.iter().enumerate() {
+        let files = cf_level.get_files();
+        if i != 0 {
+            assert_eq!(files.len(), 0);
+            continue;
+        }
+        assert_eq!(files.len(), num_files as usize);
+        for f in files {
+            assert!(f.get_size() > 0);
+            assert!(f.get_name().len() > 0);
+        }
+    }
+}