use struct WideColumn

widecolumn

Author: Korniichyk

.github/workflows/rust.yml

@@ -2,7 +2,7 @@ name: RocksDB CI
 
 on: [push, pull_request]
 env:
-  RUST_VERSION: 1.71.1
+  RUST_VERSION: 1.88
   CARGO_TERM_COLOR: always
 
 jobs:

librocksdb-sys/rocksdb

@@ -11,12 +11,14 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-
+use crate::wide::db_wide_columns::WideColumns;
+use crate::wide::db_wide_columns::WideColumn;
 use crate::{
     db,
     db::{DBAccess, DB},
     column_family::AsColumnFamilyRef,
     ffi, Error, ReadOptions, WriteBatch,
+    
 };
 use libc::{c_char, c_uchar, size_t};
 use std::{marker::PhantomData, slice};
@@ -115,33 +117,38 @@ impl<'a, D: DBAccess> DBATGIteratorWithThreadMode<'a, D> {
         }
     }
 
-    pub fn attribute_groups(&self) ->  Vec<Result<Option<Vec<u8>>, Error>> {
+    pub fn attribute_groups(&self) ->  Vec<WideColumn> {
         if self.valid() {
             self.attribute_groups_impl()
         } else {
-            vec![]
+            let mut result = Vec::new();
+            result.push(WideColumn { cf: String::new(), value: Vec::new()});
+            return result;
         }
     }
 
-    fn attribute_groups_impl(&self) -> Vec<Result<Option<Vec<u8>>, Error>> {
-        let mut len: size_t = 0;
-
-        let mut values: *mut *mut c_char = ptr::null_mut();
-        let mut values_sizes: *mut size_t = ptr::null_mut();
-        let mut errors: *mut *mut c_char = ptr::null_mut();
+    fn attribute_groups_impl(&self) ->  Vec<WideColumn> {
+        let mut values: *mut *mut ffi::rocksdb_widecolumns_t = ptr::null_mut();
+        let mut values_sizes: usize = 0;
 
         unsafe {
             ffi::rocksdb_iter_attribute_groups(
                 self.inner.as_ptr(), 
                 &mut values,
-                &mut values_sizes,
-                &mut errors,
-                &mut len);
-
-            let values = slice::from_raw_parts(values, len);
-            let values_sizes = slice::from_raw_parts(values_sizes, len);
-            let errors = slice::from_raw_parts(errors, len);
-            db::convert_values(values.to_vec(), values_sizes.to_vec(), errors.to_vec())
+                &mut values_sizes);
+            
+
+            let list = slice::from_raw_parts(values, values_sizes);
+            let mut result = Vec::new();
+
+            for col in list {
+                let wc = WideColumns::from_c(col.clone());
+                let value = wc.value().to_vec();
+                let cf = String::from_utf8_lossy(wc.name()).into_owned();
+                result.push(WideColumn { cf,  value: value });
+            }
+
+            result  
         } 
     }
 

src/db_iterator.rs

@@ -93,7 +93,7 @@ mod db;
 mod db_iterator;
 mod db_options;
 mod db_pinnable_slice;
-mod wide;
+pub mod wide;
 mod env;
 mod iter_range;
 pub mod merge_operator;
@@ -131,6 +131,7 @@ pub use crate::{
         UniversalCompactionStopStyle, WaitForCompactOptions, WriteBufferManager, WriteOptions,
     },
     wide::db_wide_columns::WideColumns,
+    wide::db_wide_columns::WideColumn,
     db_pinnable_slice::DBPinnableSlice,
     env::Env,
     ffi_util::CStrLike,

src/lib.rs

@@ -4,9 +4,10 @@ use libc::size_t;
 use std::marker::PhantomData;
 use std::slice;
 
-pub struct WideColumn <'a> {
-  name: &'a str,
-  value: &'a str,
+#[derive(Debug, Clone)]
+pub struct WideColumn{
+  pub cf:   String,
+  pub value: Vec<u8>,
 }
 
 pub struct WideColumns<'a> {

src/wide/db_wide_columns.rs

@@ -16,9 +16,11 @@ mod util;
 
 use pretty_assertions::assert_eq;
 
-use rocksdb::{Direction, IteratorMode, MemtableFactory, Options, DB, DBRawIteratorWithThreadMode, WideColumns};
+use rocksdb::{Direction, IteratorMode, MemtableFactory, Options, DB, DBRawIteratorWithThreadMode};
 use util::{assert_iter, assert_iter_reversed, pair, DBPath};
 use rocksdb::ReadOptions;
+use rocksdb::wide::db_wide_columns::WideColumn;
+
 
 #[test]
 #[allow(clippy::cognitive_complexity)]
@@ -359,14 +361,11 @@ fn test_atg_iterator() {
 
         while it.valid() {
             let key: Box<[u8]> = it.key().unwrap().into();
-            let atg: Vec<u8> = it.attribute_groups()
-                .into_iter()
-                .map(|ag| ag.unwrap())
-                .filter(|o| o.is_some())
-                .flat_map(|ag| ag.unwrap())
-                .collect();
-
-            println!("atg|{:?}=>{:?}", key, atg);
+            let atg: Vec<WideColumn> = it.attribute_groups();
+
+            for col in &atg {
+    println!("cf={:?}", col);
+}
             it.next();
         }