attributegroup ->atg

src/db.rs

@@ -17,12 +17,13 @@
     column_family::AsColumnFamilyRef,
     column_family::BoundColumnFamily,
     column_family::UnboundColumnFamily,
     db_options::OptionsMustOutliveDB,
     ffi,
     ffi_util::{from_cstr, opt_bytes_to_ptr, raw_data, to_cpath, CStrLike},
     ColumnFamily, ColumnFamilyDescriptor, CompactOptions, DBIteratorWithThreadMode,
-    DBRawAttributeGroupIteratorWithThreadMode, DBPinnableSlice, DBRawIteratorWithThreadMode, DBWALIterator, 
-    Direction, Error, FlushOptions, IngestExternalFileOptions, IteratorMode, Options, ReadOptions, SnapshotWithThreadMode,
+    DBPinnableSlice, DBRawIteratorWithThreadMode, DBWALIterator, Direction, Error, FlushOptions,
+    DBATGIteratorWithThreadMode,
+    IngestExternalFileOptions, IteratorMode, Options, ReadOptions, SnapshotWithThreadMode,
     WaitForCompactOptions, WriteBatch, WriteOptions, DEFAULT_COLUMN_FAMILY_NAME,
 };
 
@@ -155,11 +156,11 @@
         readopts: &ReadOptions,
     ) -> *mut ffi::rocksdb_iterator_t;
 
-    unsafe fn create_iterator_attribute_group(
+    unsafe fn create_iterator_atg(
         &self,
         handles: &[&impl AsColumnFamilyRef],
         readopts: &ReadOptions,
-    ) -> *mut ffi::rocksdb_iterator_attributegroup_t;
+    ) -> *mut ffi::rocksdb_iterator_atg_t;
 
     fn get_opt<K: AsRef<[u8]>>(
         &self,
@@ -234,25 +235,25 @@
         readopts: &ReadOptions,
     ) -> *mut ffi::rocksdb_iterator_t {
         let mut cfs = cfs.iter().map(|cf| cf.inner()).collect::<Vec<_>>();
-
         ffi::rocksdb_create_iterator_coalescing(
             self.inner.inner(),
             readopts.inner,
             cfs.as_mut_ptr(), 
             cfs.len() as libc::size_t)
     }
 
-    unsafe fn create_iterator_attribute_group(&self,
+    unsafe fn create_iterator_atg(
+        &self,
         cfs: &[&impl AsColumnFamilyRef],
         readopts: &ReadOptions,
-    ) -> *mut ffi::rocksdb_iterator_attributegroup_t {
+    ) -> *mut ffi::rocksdb_iterator_atg_t {
         let mut cfs = cfs.iter().map(|cf| cf.inner()).collect::<Vec<_>>();
-
-        ffi::rocksdb_create_iterator_attribute_group(
+        // create atg
+        ffi::rocksdb_create_iterator_atg(
             self.inner.inner(),
-            readopts.inner,
-            cfs.as_mut_ptr(),
-            cfs.len() as libc::size_t)
+            cfs.as_mut_ptr(), 
+            cfs.len() as libc::size_t,
+            readopts.inner)
     }
 
     fn get_opt<K: AsRef<[u8]>>(
@@ -1533,7 +1534,7 @@
             IteratorMode::From(prefix.as_ref(), Direction::Forward),
         )
     }
 
     pub fn coalescing_iterator<'a: 'b, 'b>(
         &'a self,
         cfs: &[&impl AsColumnFamilyRef]
@@ -1542,12 +1543,12 @@
         DBRawIteratorWithThreadMode::new_coalesce(self, cfs, opts)
     }
 
     pub fn atg_iterator<'a: 'b, 'b>(
         &'a self,
-        cfs: &[&impl AsColumnFamilyRef]
-    )-> DBRawAttributeGroupIteratorWithThreadMode<'b, Self> {
-        let opts = ReadOptions::default();
-        DBRawAttributeGroupIteratorWithThreadMode::new(self, cfs, opts)
+        cfs: &[&impl AsColumnFamilyRef],
+        opts: ReadOptions
+    ) -> DBATGIteratorWithThreadMode<'b, Self> {
+        DBATGIteratorWithThreadMode::new(self, cfs, opts)
     }
 
     /// Opens a raw iterator over the database, using the default read options

src/db_iterator.rs

@@ -10,7 +10,7 @@
 // distributed under the License is distributed on an "AS IS" BASIS,
 // 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::{
     db,
@@ -19,43 +19,26 @@
     ffi, Error, ReadOptions, WriteBatch,
 };
 use libc::{c_char, c_uchar, size_t};
 use std::{marker::PhantomData, slice};
 use std::ptr;
 
-pub type DBAtgIterator<'a> = DBRawAttributeGroupIteratorWithThreadMode<'a, DB>;
+pub type DBATGIterator<'a> = DBATGIteratorWithThreadMode<'a, DB>;
 
-pub struct DBRawAttributeGroupIteratorWithThreadMode<'a, D: DBAccess> {
-    inner: std::ptr::NonNull<ffi::rocksdb_iterator_attributegroup_t>,
-
-    /// When iterate_lower_bound or iterate_upper_bound are set, the inner
-    /// C iterator keeps a pointer to the upper bound inside `_readopts`.
-    /// Storing this makes sure the upper bound is always alive when the
-    /// iterator is being used.
-    ///
-    /// And yes, we need to store the entire ReadOptions structure since C++
-    /// ReadOptions keep reference to C rocksdb_readoptions_t wrapper which
-    /// point to vectors we own.  See issue #660.
+pub struct DBATGIteratorWithThreadMode<'a, D: DBAccess> {
+    inner: std::ptr::NonNull<ffi::rocksdb_iterator_atg_t>,
     _readopts: ReadOptions,
-
     db: PhantomData<&'a D>,
 }
 
-impl<'a, D: DBAccess> DBRawAttributeGroupIteratorWithThreadMode<'a, D> {
-    pub(crate) fn new(
-        db: &'a D,
+impl<'a, D: DBAccess> DBATGIteratorWithThreadMode<'a, D> {
+    pub(crate) fn new(db: &D, 
         cfs: &[&impl AsColumnFamilyRef],
-        readopts: ReadOptions,
-    ) -> Self{
-        let inner = unsafe { db.create_iterator_attribute_group(cfs, &readopts) };
+        readopts: ReadOptions) -> Self {
+        
+        let inner = unsafe { db.create_iterator_atg(cfs, &readopts) };
         Self::from_inner(inner, readopts)
     }
 
-    /// Returns `true` if the iterator is valid. An iterator is invalidated when
-    /// it reaches the end of its defined range, or when it encounters an error.
-    ///
-    /// To check whether the iterator encountered an error after `valid` has
-    /// returned `false`, use the [`status`](DBRawIteratorWithThreadMode::status) method. `status` will never
-    /// return an error when `valid` is `true`.
     pub fn valid(&self) -> bool {
         unsafe { ffi::rocksdb_iter_atg_valid(self.inner.as_ptr()) != 0 }
     }
@@ -66,12 +49,33 @@
         }
     }
 
-    // Returns a slice of the current key.
-    pub fn key(&self) -> Option<&[u8]> {
-        if self.valid() {
-            Some(self.key_impl())
-        } else {
-            None
+    pub fn seek_to_last(&mut self) {
+        unsafe {
+            ffi::rocksdb_iter_atg_seek_to_last(self.inner.as_ptr());
+        }
+    }
+
+    pub fn seek<K: AsRef<[u8]>>(&mut self, key: K) {
+        let key = key.as_ref();
+
+        unsafe {
+            ffi::rocksdb_iter_atg_seek(
+                self.inner.as_ptr(),
+                key.as_ptr() as *const c_char,
+                key.len() as size_t,
+            );
+        }
+    }
+
+    pub fn seek_for_prev<K: AsRef<[u8]>>(&mut self, key: K) {
+        let key = key.as_ref();
+
+        unsafe {
+            ffi::rocksdb_iter_atg_seek_for_prev(
+                self.inner.as_ptr(),
+                key.as_ptr() as *const c_char,
+                key.len() as size_t,
+            );
         }
     }
 
@@ -84,31 +88,22 @@
         }
     }
 
-    pub fn attribute_groups(&mut self) -> Vec<Result<Option<Vec<u8>>, Error>>{
+    pub fn prev(&mut self) {
         if self.valid() {
-            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();
             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())
+                ffi::rocksdb_iter_atg_prev(self.inner.as_ptr());
             }
+        }
+    }
+
+    pub fn key(&self) -> Option<&[u8]> {
+        if self.valid() {
+            Some(self.key_impl())
         } else {
-            vec![]
+            None
         }
     }
 
-    /// Returns a slice of the current key; assumes the iterator is valid.
     fn key_impl(&self) -> &[u8] {
         // Safety Note: This is safe as all methods that may invalidate the buffer returned
         // take `&mut self`, so borrow checker will prevent use of buffer after seek.
@@ -117,10 +112,40 @@
             let key_len_ptr: *mut size_t = &mut key_len;
             let key_ptr = ffi::rocksdb_iter_atg_key(self.inner.as_ptr(), key_len_ptr);
             slice::from_raw_parts(key_ptr as *const c_uchar, key_len)
         }
     }
 
-    fn from_inner(inner: *mut ffi::rocksdb_iterator_attributegroup_t, readopts: ReadOptions) -> Self {
+    pub fn attribute_groups(&self) ->  Vec<Result<Option<Vec<u8>>, Error>> {
+        if self.valid() {
+            self.attribute_groups_impl()
+        } else {
+            vec![]
+        }
+    }
+
+    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();
+
+        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())
+        } 
+    }
+
+    fn from_inner(inner: *mut ffi::rocksdb_iterator_atg_t, readopts: ReadOptions) -> Self {
         let inner = std::ptr::NonNull::new(inner).unwrap();
         Self {
             inner,
@@ -130,16 +155,16 @@
     }
 }
 
-impl<D: DBAccess> Drop for DBRawAttributeGroupIteratorWithThreadMode<'_, D> {
+impl<D: DBAccess> Drop for DBATGIteratorWithThreadMode<'_, D> {
     fn drop(&mut self) {
         unsafe {
-            ffi::rocksdb_iter_attributegroup_destroy(self.inner.as_ptr());
+            ffi::rocksdb_iter_atg_destroy(self.inner.as_ptr());
         }
     }
 }
 
-unsafe impl<D: DBAccess> Send for DBRawAttributeGroupIteratorWithThreadMode<'_, D> {}
-unsafe impl<D: DBAccess> Sync for DBRawAttributeGroupIteratorWithThreadMode<'_, D> {}
+unsafe impl<D: DBAccess> Send for DBATGIteratorWithThreadMode<'_, D> {}
+unsafe impl<D: DBAccess> Sync for DBATGIteratorWithThreadMode<'_, D> {}
 
 /// A type alias to keep compatibility. See [`DBRawIteratorWithThreadMode`] for details
 pub type DBRawIterator<'a> = DBRawIteratorWithThreadMode<'a, DB>;
@@ -236,6 +261,14 @@
         Self::from_inner(inner, readopts)
     }
 
+    // pub(crate) fn new_atg(db: &'a D,
+    //     cfs: &[&impl AsColumnFamilyRef],
+    //     readopts: ReadOptions,
+    // ) -> Self {
+    //     let inner = unsafe { db.create_iterator_atg(cfs, &readopts) };
+    //     Self::from_inner(inner, readopts)
+    // }
+
     fn from_inner(inner: *mut ffi::rocksdb_iterator_t, readopts: ReadOptions) -> Self {
         // This unwrap will never fail since rocksdb_create_iterator and
         // rocksdb_create_iterator_cf functions always return non-null. They

src/lib.rs

@@ -119,7 +119,8 @@ pub use crate::{
     },
     db_iterator::{
         DBIterator, DBIteratorWithThreadMode, DBRawIterator, DBRawIteratorWithThreadMode,
-        DBWALIterator, Direction, IteratorMode, DBAtgIterator, DBRawAttributeGroupIteratorWithThreadMode
+        DBWALIterator, Direction, IteratorMode,
+        DBATGIterator, DBATGIteratorWithThreadMode,
     },
     db_options::{
         BlockBasedIndexType, BlockBasedOptions, BottommostLevelCompaction, Cache, ChecksumType,
@@ -247,7 +248,7 @@ mod test {
         db_options::{CacheWrapper, WriteBufferManagerWrapper},
         env::{Env, EnvWrapper},
         BlockBasedOptions, BoundColumnFamily, Cache, ColumnFamily, ColumnFamilyDescriptor,
-        DBIterator, DBRawIterator, DBAtgIterator, IngestExternalFileOptions, Options, PlainTableFactoryOptions,
+        DBIterator, DBRawIterator, DBATGIterator, IngestExternalFileOptions, Options, PlainTableFactoryOptions,
         ReadOptions, Snapshot, SstFileWriter, WriteBatch, WriteBufferManager, WriteOptions, DB,
     };
 
@@ -263,7 +264,7 @@ mod test {
         is_send::<DB>();
         is_send::<DBIterator<'_>>();
         is_send::<DBRawIterator<'_>>();
-        is_send::<DBAtgIterator<'_>>();
+        is_send::<DBATGIterator<'_>>();
         is_send::<Snapshot>();
         is_send::<Options>();
         is_send::<ReadOptions>();

src/transactions/transaction.rs

@@ -70,18 +70,18 @@ impl<DB> DBAccess for Transaction<'_, DB> {
             cfs.len() as libc::size_t)
     }
 
-    unsafe fn create_iterator_attribute_group(
+    unsafe fn create_iterator_atg(
         &self,
         cfs: &[&impl AsColumnFamilyRef],
         readopts: &ReadOptions,
-    ) -> *mut ffi::rocksdb_iterator_attributegroup_t {
+    ) -> *mut ffi::rocksdb_iterator_atg_t {
         let mut cfs = cfs.iter().map(|cf| cf.inner()).collect::<Vec<_>>();
 
-        ffi::rocksdb_transaction_create_iterator_attribute_group(
+        ffi::rocksdb_transaction_create_iterator_atg(
             self.inner,
-            readopts.inner,
-            cfs.as_mut_ptr(),
-            cfs.len() as libc::size_t)
+            cfs.as_mut_ptr(), 
+            cfs.len() as libc::size_t,
+            readopts.inner)
     }
 
     fn get_opt<K: AsRef<[u8]>>(

src/transactions/transaction_db.rs

@@ -123,18 +123,18 @@ impl<T: ThreadMode> DBAccess for TransactionDB<T> {
             cfs.len() as libc::size_t)
     }
 
-    unsafe fn create_iterator_attribute_group(
+    unsafe fn create_iterator_atg(
         &self,
         cfs: &[&impl AsColumnFamilyRef],
         readopts: &ReadOptions,
-    ) -> *mut ffi::rocksdb_iterator_attributegroup_t {
+    ) -> *mut ffi::rocksdb_iterator_atg_t {
         let mut cfs = cfs.iter().map(|cf| cf.inner()).collect::<Vec<_>>();
 
-        ffi::rocksdb_transactiondb_create_iterator_attribute_group(
+        ffi::rocksdb_transactiondb_create_iterator_atg(
             self.inner,
-            readopts.inner,
-            cfs.as_mut_ptr(),
-            cfs.len() as libc::size_t)
+            cfs.as_mut_ptr(), 
+            cfs.len() as libc::size_t, 
+            readopts.inner)
     }
 
     fn get_opt<K: AsRef<[u8]>>(