From fbc7f83c65f2e4fe167cc67d12fd2fd91f21693b Mon Sep 17 00:00:00 2001 From: Snizhana Korniichuk Date: Mon, 18 Aug 2025 15:42:22 +0300 Subject: [PATCH 1/8] update db --- librocksdb-sys/rocksdb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/librocksdb-sys/rocksdb b/librocksdb-sys/rocksdb index db24347e1..92bc3e8a0 160000 --- a/librocksdb-sys/rocksdb +++ b/librocksdb-sys/rocksdb @@ -1 +1 @@ -Subproject commit db24347e14ef3da18451283d2730d0c35f28652f +Subproject commit 92bc3e8a02434b899abf969017dded2fa5480fe8 From 91a1bb1b26d23e91677b1add07c89060bae19108 Mon Sep 17 00:00:00 2001 From: Snizhana Korniichuk Date: Mon, 18 Aug 2025 16:23:00 +0300 Subject: [PATCH 2/8] atg stubs --- src/db.rs | 27 +++++++++++++++++++++++++++ src/db_iterator.rs | 8 ++++++++ src/transactions/transaction.rs | 14 ++++++++++++++ src/transactions/transaction_db.rs | 14 ++++++++++++++ 4 files changed, 63 insertions(+) diff --git a/src/db.rs b/src/db.rs index 7478e9acf..f1855f775 100644 --- a/src/db.rs +++ b/src/db.rs @@ -155,6 +155,12 @@ pub trait DBAccess { readopts: &ReadOptions, ) -> *mut ffi::rocksdb_iterator_t; + unsafe fn create_iterator_atg( + &self, + handles: &[&impl AsColumnFamilyRef], + readopts: &ReadOptions, + ) -> *mut ffi::rocksdb_iterator_t; + fn get_opt>( &self, key: K, @@ -228,7 +234,20 @@ impl DBAccess for DBCommon { readopts: &ReadOptions, ) -> *mut ffi::rocksdb_iterator_t { let mut cfs = cfs.iter().map(|cf| cf.inner()).collect::>(); + ffi::rocksdb_create_iterator_coalescing( + self.inner.inner(), + readopts.inner, + cfs.as_mut_ptr(), + cfs.len() as libc::size_t) + } + unsafe fn create_iterator_atg( + &self, + cfs: &[&impl AsColumnFamilyRef], + readopts: &ReadOptions, + ) -> *mut ffi::rocksdb_iterator_t { + let mut cfs = cfs.iter().map(|cf| cf.inner()).collect::>(); + // create atg ffi::rocksdb_create_iterator_coalescing( self.inner.inner(), readopts.inner, @@ -1523,6 +1542,14 @@ impl DBCommon { DBRawIteratorWithThreadMode::new_coalesce(self, cfs, opts) } + pub fn attribute_group_iterator<'a: 'b, 'b>( + &'a self, + cfs: &[&impl AsColumnFamilyRef], + opts: ReadOptions + ) -> DBRawIteratorWithThreadMode<'b, Self> { + DBRawIteratorWithThreadMode::new_atg(self, cfs, opts) + } + /// Opens a raw iterator over the database, using the default read options pub fn raw_iterator<'a: 'b, 'b>(&'a self) -> DBRawIteratorWithThreadMode<'b, Self> { let opts = ReadOptions::default(); diff --git a/src/db_iterator.rs b/src/db_iterator.rs index c432048bd..03281c79d 100644 --- a/src/db_iterator.rs +++ b/src/db_iterator.rs @@ -115,6 +115,14 @@ impl<'a, D: DBAccess> DBRawIteratorWithThreadMode<'a, D> { 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 diff --git a/src/transactions/transaction.rs b/src/transactions/transaction.rs index 263f21ac7..10322c316 100644 --- a/src/transactions/transaction.rs +++ b/src/transactions/transaction.rs @@ -70,6 +70,20 @@ impl DBAccess for Transaction<'_, DB> { cfs.len() as libc::size_t) } + unsafe fn create_iterator_atg( + &self, + cfs: &[&impl AsColumnFamilyRef], + readopts: &ReadOptions, + ) -> *mut ffi::rocksdb_iterator_t { + let mut cfs = cfs.iter().map(|cf| cf.inner()).collect::>(); + + ffi::rocksdb_transaction_create_iterator_coalescing( + self.inner, + readopts.inner, + cfs.as_mut_ptr(), + cfs.len() as libc::size_t) + } + fn get_opt>( &self, key: K, diff --git a/src/transactions/transaction_db.rs b/src/transactions/transaction_db.rs index 520ac904d..0d1cf128b 100644 --- a/src/transactions/transaction_db.rs +++ b/src/transactions/transaction_db.rs @@ -123,6 +123,20 @@ impl DBAccess for TransactionDB { cfs.len() as libc::size_t) } + unsafe fn create_iterator_atg( + &self, + cfs: &[&impl AsColumnFamilyRef], + readopts: &ReadOptions, + ) -> *mut ffi::rocksdb_iterator_t { + let mut cfs = cfs.iter().map(|cf| cf.inner()).collect::>(); + + ffi::rocksdb_transactiondb_create_iterator_coalescing( + self.inner, + readopts.inner, + cfs.as_mut_ptr(), + cfs.len() as libc::size_t) + } + fn get_opt>( &self, key: K, From 42dfe01cd368676d7c51d57a8d809ca8c3e8ec61 Mon Sep 17 00:00:00 2001 From: Snizhana Korniichuk Date: Tue, 19 Aug 2025 14:20:11 +0300 Subject: [PATCH 3/8] atg iterator --- librocksdb-sys/rocksdb | 2 +- src/db.rs | 15 ++-- src/db_iterator.rs | 122 +++++++++++++++++++++++++++-- src/lib.rs | 4 +- src/transactions/transaction.rs | 8 +- src/transactions/transaction_db.rs | 8 +- tests/test_iterator.rs | 42 ++++++++++ 7 files changed, 177 insertions(+), 24 deletions(-) diff --git a/librocksdb-sys/rocksdb b/librocksdb-sys/rocksdb index 92bc3e8a0..c69d09c8e 160000 --- a/librocksdb-sys/rocksdb +++ b/librocksdb-sys/rocksdb @@ -1 +1 @@ -Subproject commit 92bc3e8a02434b899abf969017dded2fa5480fe8 +Subproject commit c69d09c8e62aba90fb9498433c4ec83d9bb8708f diff --git a/src/db.rs b/src/db.rs index f1855f775..16c1459cf 100644 --- a/src/db.rs +++ b/src/db.rs @@ -22,6 +22,7 @@ use crate::{ ffi_util::{from_cstr, opt_bytes_to_ptr, raw_data, to_cpath, CStrLike}, ColumnFamily, ColumnFamilyDescriptor, CompactOptions, DBIteratorWithThreadMode, DBPinnableSlice, DBRawIteratorWithThreadMode, DBWALIterator, Direction, Error, FlushOptions, + DBATGIteratorWithThreadMode, IngestExternalFileOptions, IteratorMode, Options, ReadOptions, SnapshotWithThreadMode, WaitForCompactOptions, WriteBatch, WriteOptions, DEFAULT_COLUMN_FAMILY_NAME, }; @@ -159,7 +160,7 @@ pub trait DBAccess { &self, handles: &[&impl AsColumnFamilyRef], readopts: &ReadOptions, - ) -> *mut ffi::rocksdb_iterator_t; + ) -> *mut ffi::rocksdb_iterator_atg_t; fn get_opt>( &self, @@ -245,14 +246,14 @@ impl DBAccess for DBCommon { &self, cfs: &[&impl AsColumnFamilyRef], readopts: &ReadOptions, - ) -> *mut ffi::rocksdb_iterator_t { + ) -> *mut ffi::rocksdb_iterator_atg_t { let mut cfs = cfs.iter().map(|cf| cf.inner()).collect::>(); // create atg - ffi::rocksdb_create_iterator_coalescing( + ffi::rocksdb_create_iterator_atg( self.inner.inner(), - readopts.inner, cfs.as_mut_ptr(), - cfs.len() as libc::size_t) + cfs.len() as libc::size_t, + readopts.inner) } fn get_opt>( @@ -1546,8 +1547,8 @@ impl DBCommon { &'a self, cfs: &[&impl AsColumnFamilyRef], opts: ReadOptions - ) -> DBRawIteratorWithThreadMode<'b, Self> { - DBRawIteratorWithThreadMode::new_atg(self, cfs, opts) + ) -> DBATGIteratorWithThreadMode<'b, Self> { + DBATGIteratorWithThreadMode::new(self, cfs, opts) } /// Opens a raw iterator over the database, using the default read options diff --git a/src/db_iterator.rs b/src/db_iterator.rs index 03281c79d..d07fb1eec 100644 --- a/src/db_iterator.rs +++ b/src/db_iterator.rs @@ -13,12 +13,120 @@ // limitations under the License. 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}; +use std::ptr; + +pub type DBATGIterator<'a> = DBATGIteratorWithThreadMode<'a, DB>; + +pub struct DBATGIteratorWithThreadMode<'a, D: DBAccess> { + inner: std::ptr::NonNull, + _readopts: ReadOptions, + db: PhantomData<&'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_atg(cfs, &readopts) }; + Self::from_inner(inner, readopts) + } + + pub fn valid(&self) -> bool { + unsafe { ffi::rocksdb_iter_atg_valid(self.inner.as_ptr()) != 0 } + } + + pub fn seek_to_first(&mut self) { + unsafe { + ffi::rocksdb_iter_atg_seek_to_first(self.inner.as_ptr()); + } + } + + /// Seeks to the next key. + pub fn next(&mut self) { + if self.valid() { + unsafe { + ffi::rocksdb_iter_atg_next(self.inner.as_ptr()); + } + } + } + + pub fn key(&self) -> Option<&[u8]> { + if self.valid() { + Some(self.key_impl()) + } else { + None + } + } + + 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. + unsafe { + let mut key_len: size_t = 0; + 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) + } + } + + pub fn attribute_groups(&self) -> Vec>, Error>> { + if self.valid() { + self.attribute_groups_impl() + } else { + vec![] + } + } + + fn attribute_groups_impl(&self) -> Vec>, 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, + _readopts: readopts, + db: PhantomData, + } + } +} + +impl Drop for DBATGIteratorWithThreadMode<'_, D> { + fn drop(&mut self) { + unsafe { + ffi::rocksdb_iter_atg_destroy(self.inner.as_ptr()); + } + } +} + +unsafe impl Send for DBATGIteratorWithThreadMode<'_, D> {} +unsafe impl Sync for DBATGIteratorWithThreadMode<'_, D> {} /// A type alias to keep compatibility. See [`DBRawIteratorWithThreadMode`] for details pub type DBRawIterator<'a> = DBRawIteratorWithThreadMode<'a, DB>; @@ -115,13 +223,13 @@ impl<'a, D: DBAccess> DBRawIteratorWithThreadMode<'a, D> { 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) - } + // 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 diff --git a/src/lib.rs b/src/lib.rs index b603b8942..a062d2789 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -120,6 +120,7 @@ pub use crate::{ db_iterator::{ DBIterator, DBIteratorWithThreadMode, DBRawIterator, DBRawIteratorWithThreadMode, 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, IngestExternalFileOptions, Options, PlainTableFactoryOptions, + DBIterator, DBRawIterator, DBATGIterator, IngestExternalFileOptions, Options, PlainTableFactoryOptions, ReadOptions, Snapshot, SstFileWriter, WriteBatch, WriteBufferManager, WriteOptions, DB, }; @@ -263,6 +264,7 @@ mod test { is_send::(); is_send::>(); is_send::>(); + is_send::>(); is_send::(); is_send::(); is_send::(); diff --git a/src/transactions/transaction.rs b/src/transactions/transaction.rs index 10322c316..c8afbd146 100644 --- a/src/transactions/transaction.rs +++ b/src/transactions/transaction.rs @@ -74,14 +74,14 @@ impl DBAccess for Transaction<'_, DB> { &self, cfs: &[&impl AsColumnFamilyRef], readopts: &ReadOptions, - ) -> *mut ffi::rocksdb_iterator_t { + ) -> *mut ffi::rocksdb_iterator_atg_t { let mut cfs = cfs.iter().map(|cf| cf.inner()).collect::>(); - ffi::rocksdb_transaction_create_iterator_coalescing( + ffi::rocksdb_transaction_create_iterator_atg( self.inner, - readopts.inner, cfs.as_mut_ptr(), - cfs.len() as libc::size_t) + cfs.len() as libc::size_t, + readopts.inner) } fn get_opt>( diff --git a/src/transactions/transaction_db.rs b/src/transactions/transaction_db.rs index 0d1cf128b..e8b9ed11f 100644 --- a/src/transactions/transaction_db.rs +++ b/src/transactions/transaction_db.rs @@ -127,14 +127,14 @@ impl DBAccess for TransactionDB { &self, cfs: &[&impl AsColumnFamilyRef], readopts: &ReadOptions, - ) -> *mut ffi::rocksdb_iterator_t { + ) -> *mut ffi::rocksdb_iterator_atg_t { let mut cfs = cfs.iter().map(|cf| cf.inner()).collect::>(); - ffi::rocksdb_transactiondb_create_iterator_coalescing( + ffi::rocksdb_transactiondb_create_iterator_atg( self.inner, - readopts.inner, cfs.as_mut_ptr(), - cfs.len() as libc::size_t) + cfs.len() as libc::size_t, + readopts.inner) } fn get_opt>( diff --git a/tests/test_iterator.rs b/tests/test_iterator.rs index e46e7db52..a6557aa48 100644 --- a/tests/test_iterator.rs +++ b/tests/test_iterator.rs @@ -18,6 +18,7 @@ use pretty_assertions::assert_eq; use rocksdb::{Direction, IteratorMode, MemtableFactory, Options, DB, DBRawIteratorWithThreadMode, WideColumns}; use util::{assert_iter, assert_iter_reversed, pair, DBPath}; +use rocksdb::ReadOptions; #[test] #[allow(clippy::cognitive_complexity)] @@ -331,6 +332,47 @@ fn test_iterator_columns() { } } +#[test] +fn test_atg_iterator() { + let path = DBPath::new("_rust_rocksdb_terator_atg_test"); + { + let mut opts = Options::default(); + opts.create_if_missing(true); + opts.create_missing_column_families(true); + let db = DB::open_cf(&opts, &path, ["cf1", "cf2"]).unwrap(); + let cf1 = db.cf_handle("cf1").unwrap(); + let cf2 = db.cf_handle("cf2").unwrap(); + + const A1: &[u8] = b"a1"; // 97 49 + const A2: &[u8] = b"a2"; // 97 50 + const B1: &[u8] = b"b1"; + const B2: &[u8] = b"b2"; + + assert!(db.put_cf(&cf1, A1, A1).is_ok()); + assert!(db.put_cf(&cf1, A2, A2).is_ok()); + assert!(db.put_cf(&cf2, B1, B1).is_ok()); + assert!(db.put_cf(&cf2, B2, B2).is_ok()); + + let mut it = db.attribute_group_iterator(&[&cf1, &cf2], ReadOptions::default()); + it.seek_to_first(); + + while it.valid() { + let key: Box<[u8]> = it.key().unwrap().into(); + let atg: Vec = it.attribute_groups() + .into_iter() + .map(|ag| ag.unwrap()) + .filter(|o| o.is_some()) + .flat_map(|ag| ag.unwrap()) + .collect(); + println!("atg|{:?}=>{:?}", key, atg); + it.next(); + } + + + } +} + + #[test] fn test_iterator_outlive_db() { let t = trybuild::TestCases::new(); From 305f6763747027cfd818568d70702e5b4b59513e Mon Sep 17 00:00:00 2001 From: Snizhana Korniichuk Date: Tue, 19 Aug 2025 15:07:01 +0300 Subject: [PATCH 4/8] update sub --- librocksdb-sys/rocksdb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/librocksdb-sys/rocksdb b/librocksdb-sys/rocksdb index c69d09c8e..16ac00bc1 160000 --- a/librocksdb-sys/rocksdb +++ b/librocksdb-sys/rocksdb @@ -1 +1 @@ -Subproject commit c69d09c8e62aba90fb9498433c4ec83d9bb8708f +Subproject commit 16ac00bc15e58fd39b2f3c8862178f7f1d8f4d37 From 897e0d89b776373d3c2f800098610a39c1ea7a34 Mon Sep 17 00:00:00 2001 From: Snizhana Korniichuk Date: Tue, 19 Aug 2025 15:22:36 +0300 Subject: [PATCH 5/8] update sub --- librocksdb-sys/rocksdb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/librocksdb-sys/rocksdb b/librocksdb-sys/rocksdb index 16ac00bc1..b4c1fb9b3 160000 --- a/librocksdb-sys/rocksdb +++ b/librocksdb-sys/rocksdb @@ -1 +1 @@ -Subproject commit 16ac00bc15e58fd39b2f3c8862178f7f1d8f4d37 +Subproject commit b4c1fb9b34de4a95147aecf59a045c22dc514e73 From 7bc665d81d4ad0848a367859aefc948f146faeeb Mon Sep 17 00:00:00 2001 From: Snizhana Korniichuk Date: Wed, 20 Aug 2025 13:24:45 +0300 Subject: [PATCH 6/8] add atg seek to last --- librocksdb-sys/rocksdb | 2 +- src/db_iterator.rs | 6 ++++++ tests/test_iterator.rs | 1 - 3 files changed, 7 insertions(+), 2 deletions(-) diff --git a/librocksdb-sys/rocksdb b/librocksdb-sys/rocksdb index b4c1fb9b3..71e030691 160000 --- a/librocksdb-sys/rocksdb +++ b/librocksdb-sys/rocksdb @@ -1 +1 @@ -Subproject commit b4c1fb9b34de4a95147aecf59a045c22dc514e73 +Subproject commit 71e030691fb539c031580d7e1ebee439d59e86ce diff --git a/src/db_iterator.rs b/src/db_iterator.rs index d07fb1eec..dcce3150e 100644 --- a/src/db_iterator.rs +++ b/src/db_iterator.rs @@ -49,6 +49,12 @@ impl<'a, D: DBAccess> DBATGIteratorWithThreadMode<'a, D> { } } + pub fn seek_to_last(&mut self) { + unsafe { + ffi::rocksdb_iter_atg_seek_to_last(self.inner.as_ptr()); + } + } + /// Seeks to the next key. pub fn next(&mut self) { if self.valid() { diff --git a/tests/test_iterator.rs b/tests/test_iterator.rs index a6557aa48..20ba7e42e 100644 --- a/tests/test_iterator.rs +++ b/tests/test_iterator.rs @@ -367,7 +367,6 @@ fn test_atg_iterator() { println!("atg|{:?}=>{:?}", key, atg); it.next(); } - } } From 49a41e1e0b4e999ddf3d2470bca4c0f82172ed1c Mon Sep 17 00:00:00 2001 From: Snizhana Korniichuk Date: Wed, 20 Aug 2025 14:53:28 +0300 Subject: [PATCH 7/8] add seek and seek for prev in atg --- librocksdb-sys/rocksdb | 2 +- src/db_iterator.rs | 32 ++++++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+), 1 deletion(-) diff --git a/librocksdb-sys/rocksdb b/librocksdb-sys/rocksdb index 71e030691..a36a4a97c 160000 --- a/librocksdb-sys/rocksdb +++ b/librocksdb-sys/rocksdb @@ -1 +1 @@ -Subproject commit 71e030691fb539c031580d7e1ebee439d59e86ce +Subproject commit a36a4a97ce98e1def1e0be7790a81cd1437381ac diff --git a/src/db_iterator.rs b/src/db_iterator.rs index dcce3150e..1dd65e2d1 100644 --- a/src/db_iterator.rs +++ b/src/db_iterator.rs @@ -55,6 +55,30 @@ impl<'a, D: DBAccess> DBATGIteratorWithThreadMode<'a, D> { } } + pub fn seek>(&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>(&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, + ); + } + } + /// Seeks to the next key. pub fn next(&mut self) { if self.valid() { @@ -64,6 +88,14 @@ impl<'a, D: DBAccess> DBATGIteratorWithThreadMode<'a, D> { } } + pub fn prev(&mut self) { + if self.valid() { + unsafe { + ffi::rocksdb_iter_atg_prev(self.inner.as_ptr()); + } + } + } + pub fn key(&self) -> Option<&[u8]> { if self.valid() { Some(self.key_impl()) From 9a8966191f5ab2ecf40b305ae7402246739ad911 Mon Sep 17 00:00:00 2001 From: Snizhana Korniichuk Date: Mon, 25 Aug 2025 14:26:02 +0300 Subject: [PATCH 8/8] rename atg --- src/db.rs | 2 +- tests/test_iterator.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/db.rs b/src/db.rs index 16c1459cf..37d7ef98f 100644 --- a/src/db.rs +++ b/src/db.rs @@ -1543,7 +1543,7 @@ impl DBCommon { DBRawIteratorWithThreadMode::new_coalesce(self, cfs, opts) } - pub fn attribute_group_iterator<'a: 'b, 'b>( + pub fn atg_iterator<'a: 'b, 'b>( &'a self, cfs: &[&impl AsColumnFamilyRef], opts: ReadOptions diff --git a/tests/test_iterator.rs b/tests/test_iterator.rs index 20ba7e42e..a119cd65e 100644 --- a/tests/test_iterator.rs +++ b/tests/test_iterator.rs @@ -353,7 +353,7 @@ fn test_atg_iterator() { assert!(db.put_cf(&cf2, B1, B1).is_ok()); assert!(db.put_cf(&cf2, B2, B2).is_ok()); - let mut it = db.attribute_group_iterator(&[&cf1, &cf2], ReadOptions::default()); + let mut it = db.atg_iterator(&[&cf1, &cf2], ReadOptions::default()); it.seek_to_first(); while it.valid() {