From 43979a529dc2969baba5126c5cce8e360713a906 Mon Sep 17 00:00:00 2001 From: "zeli.lwb" Date: Wed, 17 Jan 2024 16:07:28 +0800 Subject: [PATCH] [Fix] review --- src/client/filter.rs | 194 +++++++++++++++++--------------- src/rpc/protocol/payloads.rs | 8 +- tests/test_table_client_hash.rs | 154 +++++++++++++++++-------- tests/test_table_client_key.rs | 82 +++++++++----- 4 files changed, 270 insertions(+), 168 deletions(-) diff --git a/src/client/filter.rs b/src/client/filter.rs index 151149a..35508ab 100644 --- a/src/client/filter.rs +++ b/src/client/filter.rs @@ -15,14 +15,39 @@ * #L% */ -use std::{any::Any, fmt::Write}; +use std::fmt::Write; const TABLE_COMPARE_FILTER_PREFIX: &str = "TableCompareFilter"; -pub trait Filter: Any { - fn as_any(&self) -> &dyn Any; - fn string(&self) -> String; - fn concat_string(&self, filter_string: &mut String); +pub trait FilterEncoder { + /// Encode the filter as string. + fn encode(&self) -> String; + + /// Encode the filter to the buffer. + fn encode_to(&self, buffer: &mut String); +} + +pub enum Filter { + Value(ObTableValueFilter), + List(ObTableFilterList), +} + +impl FilterEncoder for Filter { + /// Encode the filter as string. + fn encode(&self) -> String { + match self { + Filter::List(filter) => filter.encode(), + Filter::Value(filter) => filter.encode(), + } + } + + /// Encode the filter to the buffer. + fn encode_to(&self, buffer: &mut String) { + match self { + Filter::List(filter) => filter.encode_to(buffer), + Filter::Value(filter) => filter.encode_to(buffer), + } + } } #[derive(Debug, Clone, PartialEq, Eq)] @@ -60,23 +85,13 @@ pub enum FilterOp { pub struct ObTableFilterList { pub op: FilterOp, - pub filters: Vec>, -} - -#[macro_export] -macro_rules! filter_list { - ($op:expr, $($filter:expr),+ $(,)?) => { - ObTableFilterList { - op: $op, - filters: vec![$(Box::new($filter) as Box),+], - } - }; + pub filters: Vec, } impl ObTableFilterList { pub fn new(op: FilterOp, filters: I) -> Self where - I: IntoIterator>, + I: IntoIterator, { ObTableFilterList { op, @@ -84,24 +99,21 @@ impl ObTableFilterList { } } - pub fn add_filter(&mut self, filter: Box) { + pub fn add_filter(&mut self, filter: Filter) { self.filters.push(filter) } pub fn add_filters(&mut self, filters: I) where - I: IntoIterator>, + I: IntoIterator, { self.filters.extend(filters.into_iter()) } } -impl Filter for ObTableFilterList { - fn as_any(&self) -> &dyn Any { - self - } - - fn string(&self) -> String { +impl FilterEncoder for ObTableFilterList { + /// Encode the filter as string. + fn encode(&self) -> String { let string_op = match self.op { FilterOp::And => " && ", FilterOp::Or => " || ", @@ -111,18 +123,20 @@ impl Filter for ObTableFilterList { self.filters .iter() .map(|filter| { - let filter_string = filter.string(); - if filter.as_any().is::() { - filter_string - } else { - format!("({})", filter_string) + let filter_string = filter.encode(); + match filter { + Filter::List(_) => { + format!("({})", filter_string) + } + Filter::Value(_) => filter_string, } }) .collect::>() .join(string_op) } - fn concat_string(&self, filter_string: &mut String) { + /// Encode the filter to the buffer. + fn encode_to(&self, buffer: &mut String) { let string_op = match self.op { FilterOp::And => " && ", FilterOp::Or => " || ", @@ -130,20 +144,23 @@ impl Filter for ObTableFilterList { for (i, filter) in self.filters.iter().enumerate() { if i != 0 { - filter_string.push_str(string_op); + buffer.push_str(string_op); } - if filter.as_any().is::() { - filter.concat_string(filter_string); - } else { - filter_string.push('('); - filter.concat_string(filter_string); - filter_string.push(')'); + match filter { + Filter::List(filter_list) => { + buffer.push('('); + filter_list.encode_to(buffer); + buffer.push(')'); + } + Filter::Value(value_filter) => value_filter.encode_to(buffer), } } } } #[derive(Debug, Clone)] +/// Only support [`ObTableValueFilter`] on numeric type and string type +/// The value will be encoded into string and will be parsed into filter in the server pub struct ObTableValueFilter { pub op: ObCompareOperator, pub column_name: String, @@ -151,21 +168,18 @@ pub struct ObTableValueFilter { } impl ObTableValueFilter { - pub fn new(op: ObCompareOperator, column_name: U, value: V) -> Self { + pub fn new(op: ObCompareOperator, column_name: String, value: V) -> Self { ObTableValueFilter { op, - column_name: column_name.to_string(), + column_name, value: value.to_string(), } } } -impl Filter for ObTableValueFilter { - fn as_any(&self) -> &dyn Any { - self - } - - fn string(&self) -> String { +impl FilterEncoder for ObTableValueFilter { + /// Encode the filter as string. + fn encode(&self) -> String { if self.column_name.is_empty() { return String::new(); } @@ -178,10 +192,11 @@ impl Filter for ObTableValueFilter { ) } - fn concat_string(&self, filter_string: &mut String) { + /// Encode the filter to the buffer. + fn encode_to(&self, buffer: &mut String) { if !self.column_name.is_empty() { if let Err(e) = write!( - filter_string, + buffer, "{}({},'{}:{}')", TABLE_COMPARE_FILTER_PREFIX, self.op.string(), @@ -205,41 +220,43 @@ mod test { let string_column_name = "string_column"; // create ObTableValueFilter by micro rules - let filter_i16 = ObTableValueFilter::new(op.clone(), column_name, 51i16); - let filter_i32 = ObTableValueFilter::new(op.clone(), string_column_name, 51i32); - let filter_i64 = ObTableValueFilter::new(op.clone(), column_name, 51i64); - let filter_u16 = ObTableValueFilter::new(op.clone(), string_column_name, 51u16); - let filter_u32 = ObTableValueFilter::new(op.clone(), column_name, 51u32); - let filter_u64 = ObTableValueFilter::new(op.clone(), string_column_name, 51u64); - let filter_f32 = ObTableValueFilter::new(op.clone(), column_name, 51.0f32); - let filter_f64 = ObTableValueFilter::new(op.clone(), string_column_name, 51.0f64); - let filter_string = ObTableValueFilter::new(op.clone(), column_name, "51".to_string()); - let filter_str = ObTableValueFilter::new(op.clone(), string_column_name, "51"); + let filter_i16 = ObTableValueFilter::new(op.clone(), column_name.to_string(), 51i16); + let filter_i32 = ObTableValueFilter::new(op.clone(), string_column_name.to_string(), 51i32); + let filter_i64 = ObTableValueFilter::new(op.clone(), column_name.to_string(), 51i64); + let filter_u16 = ObTableValueFilter::new(op.clone(), string_column_name.to_string(), 51u16); + let filter_u32 = ObTableValueFilter::new(op.clone(), column_name.to_string(), 51u32); + let filter_u64 = ObTableValueFilter::new(op.clone(), string_column_name.to_string(), 51u64); + let filter_f32 = ObTableValueFilter::new(op.clone(), column_name.to_string(), 51.0f32); + let filter_f64 = + ObTableValueFilter::new(op.clone(), string_column_name.to_string(), 51.0f64); + let filter_string = + ObTableValueFilter::new(op.clone(), column_name.to_string(), "51".to_string()); + let filter_str = ObTableValueFilter::new(op.clone(), string_column_name.to_string(), "51"); - assert_eq!("TableCompareFilter(=,'column:51')", filter_i16.string()); + assert_eq!("TableCompareFilter(=,'column:51')", filter_i16.encode()); assert_eq!( "TableCompareFilter(=,'string_column:51')", - filter_i32.string() + filter_i32.encode() ); - assert_eq!("TableCompareFilter(=,'column:51')", filter_i64.string()); + assert_eq!("TableCompareFilter(=,'column:51')", filter_i64.encode()); assert_eq!( "TableCompareFilter(=,'string_column:51')", - filter_u16.string() + filter_u16.encode() ); - assert_eq!("TableCompareFilter(=,'column:51')", filter_u32.string()); + assert_eq!("TableCompareFilter(=,'column:51')", filter_u32.encode()); assert_eq!( "TableCompareFilter(=,'string_column:51')", - filter_u64.string() + filter_u64.encode() ); - assert_eq!("TableCompareFilter(=,'column:51')", filter_f32.string()); + assert_eq!("TableCompareFilter(=,'column:51')", filter_f32.encode()); assert_eq!( "TableCompareFilter(=,'string_column:51')", - filter_f64.string() + filter_f64.encode() ); - assert_eq!("TableCompareFilter(=,'column:51')", filter_string.string()); + assert_eq!("TableCompareFilter(=,'column:51')", filter_string.encode()); assert_eq!( "TableCompareFilter(=,'string_column:51')", - filter_str.string() + filter_str.encode() ); } @@ -249,44 +266,45 @@ mod test { let filter_list_0 = ObTableFilterList::new( FilterOp::And, vec![ - Box::new(ObTableValueFilter::new( + Filter::Value(ObTableValueFilter::new( ObCompareOperator::Equal, - column_name, + column_name.to_string(), "0", - )) as Box, - Box::new(ObTableValueFilter::new( + )), + Filter::Value(ObTableValueFilter::new( ObCompareOperator::GreaterThan, - column_name, + column_name.to_string(), "1", - )) as Box, + )), ], ); let mut filter_list_component = ObTableFilterList::new( FilterOp::And, - vec![Box::new(ObTableValueFilter::new( + vec![Filter::Value(ObTableValueFilter::new( ObCompareOperator::Equal, - column_name, + column_name.to_string(), 2, - )) as Box], + ))], ); - filter_list_component.add_filter(Box::new(ObTableValueFilter::new( + filter_list_component.add_filter(Filter::Value(ObTableValueFilter::new( ObCompareOperator::GreaterThan, - column_name, + column_name.to_string(), "3", - )) as Box); - let mut filter_list_1 = filter_list!(FilterOp::Or, filter_list_component,); - filter_list_1.add_filters(vec![Box::new(ObTableValueFilter::new( + ))); + let mut filter_list_1 = + ObTableFilterList::new(FilterOp::Or, vec![Filter::List(filter_list_component)]); + filter_list_1.add_filters(vec![Filter::Value(ObTableValueFilter::new( ObCompareOperator::GreaterThan, - column_name, + column_name.to_string(), "4", - )) as Box]); + ))]); - println!("{:?}", filter_list_0.string()); - println!("{:?}", filter_list_1.string()); + println!("{:?}", filter_list_0.encode()); + println!("{:?}", filter_list_1.encode()); assert_eq!( "TableCompareFilter(=,'column:0') && TableCompareFilter(>,'column:1')", - filter_list_0.string() + filter_list_0.encode() ); - assert_eq!("(TableCompareFilter(=,'column:2') && TableCompareFilter(>,'column:3')) || TableCompareFilter(>,'column:4')", filter_list_1.string()); + assert_eq!("(TableCompareFilter(=,'column:2') && TableCompareFilter(>,'column:3')) || TableCompareFilter(>,'column:4')", filter_list_1.encode()); } } diff --git a/src/rpc/protocol/payloads.rs b/src/rpc/protocol/payloads.rs index 647662b..f678ef2 100644 --- a/src/rpc/protocol/payloads.rs +++ b/src/rpc/protocol/payloads.rs @@ -29,8 +29,8 @@ use bytes::{Buf, BufMut, BytesMut}; use super::{ BasePayLoad, ObPayload, ObTablePacketCode, ProtoDecoder, ProtoEncoder, Result, TraceId, }; +use crate::filter::FilterEncoder; use crate::{ - client::filter::Filter, location::OB_INVALID_ID, query::{ObNewRange, ObTableQuery}, rpc::protocol::{ @@ -725,12 +725,12 @@ impl ObTableBatchOperation { /// whether meet the filter and execute the insertUp /// if check_exist is true: check if any data meet the filter /// if check_exist is false: check if all data do not meet the filter - pub fn check_and_insert_up( + pub fn check_and_insert_up( &mut self, row_keys: Vec, columns: Vec, properties: Vec, - filter: Box, + filter: T, check_exist: bool, ) { let mut option = RawObTableOperationFlag::new(); @@ -741,7 +741,7 @@ impl ObTableBatchOperation { row_keys, Some(columns), Some(properties), - Some(filter.string()), + Some(filter.encode()), Some(option), )) } diff --git a/tests/test_table_client_hash.rs b/tests/test_table_client_hash.rs index 6b99dc8..813de3e 100644 --- a/tests/test_table_client_hash.rs +++ b/tests/test_table_client_hash.rs @@ -22,7 +22,7 @@ mod utils; use obkv::{ filter::{Filter, FilterOp, ObCompareOperator, ObTableFilterList, ObTableValueFilter}, - filter_list, TableOpResult, Value, + TableOpResult, Value, }; use serial_test_derive::serial; use tokio::task; @@ -215,36 +215,36 @@ async fn test_batch_insert_or_update_with_filter() { // insert some data, will insert 0/1/2, 3 can't insert since exec_if_exist let mut batch_op = client.batch_operation(4); - let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "value"); + let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2".to_string(), "value"); batch_op.check_and_insert_up( vec![Value::from(0i64), Value::from("subKey_0")], vec!["c2".to_owned()], vec![Value::from("batchValue_0")], - Box::new(filter_0), + filter_0, false, ); - let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "value"); + let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2".to_string(), "value"); batch_op.check_and_insert_up( vec![Value::from(1i64), Value::from("subKey_1")], vec!["c2".to_owned()], vec![Value::from("batchValue_1")], - Box::new(filter_0), + filter_0, false, ); - let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "value"); + let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2".to_string(), "value"); batch_op.check_and_insert_up( vec![Value::from(2i64), Value::from("subKey_2")], vec!["c2".to_owned()], vec![Value::from("batchValue_2")], - Box::new(filter_0), + filter_0, false, ); - let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "value"); + let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2".to_string(), "value"); batch_op.check_and_insert_up( vec![Value::from(3i64), Value::from("subKey_3")], vec!["c2".to_owned()], vec![Value::from("batchValue_3")], - Box::new(filter_0), + filter_0, true, ); batch_op.set_atomic_op(false); @@ -253,50 +253,78 @@ async fn test_batch_insert_or_update_with_filter() { // update some data, only 1 will update let mut batch_op = client.batch_operation(4); - let filter_1 = filter_list!( + let filter_1 = Filter::List(ObTableFilterList::new( FilterOp::And, - ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "batchValue_1"), - ); + vec![Filter::Value(ObTableValueFilter::new( + ObCompareOperator::Equal, + "c2".to_string(), + "batchValue_1", + ))], + )); batch_op.check_and_insert_up( vec![Value::from(0i64), Value::from("subKey_0")], vec!["c2".to_owned()], vec![Value::from("updateValue_0")], - Box::new(filter_1), + filter_1, true, ); - let filter_1 = filter_list!( + let filter_1 = Filter::List(ObTableFilterList::new( FilterOp::And, - ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "batchValue_1"), - ObTableValueFilter::new(ObCompareOperator::LessThan, "c3", 1) - ); + vec![ + Filter::Value(ObTableValueFilter::new( + ObCompareOperator::Equal, + "c2".to_string(), + "batchValue_1", + )), + Filter::Value(ObTableValueFilter::new( + ObCompareOperator::LessThan, + "c3".to_string(), + 1, + )), + ], + )); batch_op.check_and_insert_up( vec![Value::from(1i64), Value::from("subKey_1")], vec!["c2".to_owned()], vec![Value::from("updateValue_1")], - Box::new(filter_1), + filter_1, true, ); - let filter_1 = filter_list!( + let filter_1 = Filter::List(ObTableFilterList::new( FilterOp::And, - ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "batchValue_1"), - ); + vec![Filter::Value(ObTableValueFilter::new( + ObCompareOperator::Equal, + "c2".to_string(), + "batchValue_1", + ))], + )); batch_op.check_and_insert_up( vec![Value::from(2i64), Value::from("subKey_2")], vec!["c2".to_owned()], vec![Value::from("updateValue_2")], - Box::new(filter_1), + filter_1, true, ); - let filter_1 = filter_list!( + let filter_1 = Filter::List(ObTableFilterList::new( FilterOp::And, - ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "batchValue_3"), - ObTableValueFilter::new(ObCompareOperator::GreaterOrEqualThan, "c3", 1), - ); + vec![ + Filter::Value(ObTableValueFilter::new( + ObCompareOperator::Equal, + "c2".to_string(), + "batchValue_3", + )), + Filter::Value(ObTableValueFilter::new( + ObCompareOperator::LessThan, + "c3".to_string(), + 1, + )), + ], + )); batch_op.check_and_insert_up( vec![Value::from(3i64), Value::from("subKey_3")], vec!["c2".to_owned()], vec![Value::from("updateValue_3")], - Box::new(filter_1), + filter_1, true, ); batch_op.set_atomic_op(false); @@ -366,15 +394,15 @@ async fn test_uint_filter() { // insert some data, will insert 0/1/2, 3 can't insert since exec_if_exist let mut batch_op = client.batch_operation(4); - let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2", 0u16); + let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2".to_string(), 0u16); batch_op.check_and_insert_up( vec![Value::from(0u8)], vec!["c2".to_owned(), "c3".to_owned(), "c4".to_owned()], vec![Value::from(0u16), Value::from(0u32), Value::from(0u64)], - Box::new(filter_0), + filter_0, false, ); - let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2", 0u16); + let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2".to_string(), 0u16); batch_op.check_and_insert_up( vec![Value::from(1u8)], vec!["c2".to_owned(), "c3".to_owned(), "c4".to_owned()], @@ -383,23 +411,23 @@ async fn test_uint_filter() { Value::from(100u32), Value::from(100u64), ], - Box::new(filter_0), + filter_0, false, ); - let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2", 0u16); + let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2".to_string(), 0u16); batch_op.check_and_insert_up( vec![Value::from(2u8)], vec!["c2".to_owned(), "c3".to_owned(), "c4".to_owned()], vec![Value::from(0u16), Value::from(0u32), Value::from(u64::MAX)], - Box::new(filter_0), + filter_0, false, ); - let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2", 0u16); + let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2".to_string(), 0u16); batch_op.check_and_insert_up( vec![Value::from(3u8)], vec!["c2".to_owned(), "c3".to_owned(), "c4".to_owned()], vec![Value::from(0u16), Value::from(0u32), Value::from(0u64)], - Box::new(filter_0), + filter_0, true, ); batch_op.set_atomic_op(false); @@ -417,50 +445,78 @@ async fn test_uint_filter() { // update some data, only 0 and 2 will update let mut batch_op = client.batch_operation(4); - let filter_1 = filter_list!( + let filter_1 = ObTableFilterList::new( FilterOp::And, - ObTableValueFilter::new(ObCompareOperator::Equal, "c2", 0u16), + vec![Filter::Value(ObTableValueFilter::new( + ObCompareOperator::Equal, + "c2".to_string(), + 0u16, + ))], ); batch_op.check_and_insert_up( vec![Value::from(0u8)], vec!["c2".to_owned()], vec![Value::from(1u16)], - Box::new(filter_1), + filter_1, true, ); - let filter_1 = filter_list!( + let filter_1 = ObTableFilterList::new( FilterOp::And, - ObTableValueFilter::new(ObCompareOperator::Equal, "c2", 100u16), - ObTableValueFilter::new(ObCompareOperator::LessThan, "c3", 100u32), + vec![ + Filter::Value(ObTableValueFilter::new( + ObCompareOperator::Equal, + "c2".to_string(), + 100u16, + )), + Filter::Value(ObTableValueFilter::new( + ObCompareOperator::LessThan, + "c3".to_string(), + 100u32, + )), + ], ); batch_op.check_and_insert_up( vec![Value::from(1u8)], vec!["c2".to_owned()], vec![Value::from(1u16)], - Box::new(filter_1), + filter_1, true, ); - let filter_1 = filter_list!( + let filter_1 = ObTableFilterList::new( FilterOp::And, - ObTableValueFilter::new(ObCompareOperator::Equal, "c4", u64::MAX), + vec![Filter::Value(ObTableValueFilter::new( + ObCompareOperator::Equal, + "c4".to_string(), + u64::MAX, + ))], ); batch_op.check_and_insert_up( vec![Value::from(2u8)], vec!["c2".to_owned()], vec![Value::from(1u16)], - Box::new(filter_1), + filter_1, true, ); - let filter_1 = filter_list!( + let filter_1 = ObTableFilterList::new( FilterOp::And, - ObTableValueFilter::new(ObCompareOperator::Equal, "c2", 0u16), - ObTableValueFilter::new(ObCompareOperator::GreaterOrEqualThan, "c3", 0u64), + vec![ + Filter::Value(ObTableValueFilter::new( + ObCompareOperator::Equal, + "c2".to_string(), + 0u16, + )), + Filter::Value(ObTableValueFilter::new( + ObCompareOperator::GreaterOrEqualThan, + "c3".to_string(), + 0u64, + )), + ], ); batch_op.check_and_insert_up( vec![Value::from(3u8)], vec!["c2".to_owned()], vec![Value::from(1u16)], - Box::new(filter_1), + filter_1, true, ); batch_op.set_atomic_op(false); diff --git a/tests/test_table_client_key.rs b/tests/test_table_client_key.rs index c15fd92..4c4bd11 100644 --- a/tests/test_table_client_key.rs +++ b/tests/test_table_client_key.rs @@ -24,7 +24,7 @@ use std::sync::Arc; use obkv::{ filter::{Filter, FilterOp, ObCompareOperator, ObTableFilterList, ObTableValueFilter}, - filter_list, ObTableClient, TableOpResult, Value, + ObTableClient, TableOpResult, Value, }; use rand::{distributions::Alphanumeric, thread_rng, Rng}; use serial_test_derive::serial; @@ -729,36 +729,36 @@ async fn test_batch_insert_or_update_with_filter() { // insert some data, will insert 0/1/2, 3 can't insert since exec_if_exist let mut batch_op = client.batch_operation(4); - let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "value"); + let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2".to_string(), "value"); batch_op.check_and_insert_up( vec![Value::from("Key_0"), Value::from("subKey_0")], vec!["c2".to_owned()], vec![Value::from("batchValue_0")], - Box::new(filter_0), + filter_0, false, ); - let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "value"); + let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2".to_string(), "value"); batch_op.check_and_insert_up( vec![Value::from("Key_1"), Value::from("subKey_1")], vec!["c2".to_owned()], vec![Value::from("batchValue_1")], - Box::new(filter_0), + filter_0, false, ); - let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "value"); + let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2".to_string(), "value"); batch_op.check_and_insert_up( vec![Value::from("Key_2"), Value::from("subKey_2")], vec!["c2".to_owned()], vec![Value::from("batchValue_2")], - Box::new(filter_0), + filter_0, false, ); - let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "value"); + let filter_0 = ObTableValueFilter::new(ObCompareOperator::Equal, "c2".to_string(), "value"); batch_op.check_and_insert_up( vec![Value::from("Key_3"), Value::from("subKey_3")], vec!["c2".to_owned()], vec![Value::from("batchValue_3")], - Box::new(filter_0), + filter_0, true, ); batch_op.set_atomic_op(false); @@ -767,50 +767,78 @@ async fn test_batch_insert_or_update_with_filter() { // update some data, only 1 will update let mut batch_op = client.batch_operation(4); - let filter_1 = filter_list!( + let filter_1 = Filter::List(ObTableFilterList::new( FilterOp::And, - ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "batchValue_1"), - ); + vec![Filter::Value(ObTableValueFilter::new( + ObCompareOperator::Equal, + "c2".to_string(), + "batchValue_1", + ))], + )); batch_op.check_and_insert_up( vec![Value::from("Key_0"), Value::from("subKey_0")], vec!["c2".to_owned()], vec![Value::from("updateValue_0")], - Box::new(filter_1), + filter_1, true, ); - let filter_1 = filter_list!( + let filter_1 = Filter::List(ObTableFilterList::new( FilterOp::And, - ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "batchValue_1"), - ObTableValueFilter::new(ObCompareOperator::LessThan, "c3", 1), - ); + vec![ + Filter::Value(ObTableValueFilter::new( + ObCompareOperator::Equal, + "c2".to_string(), + "batchValue_1", + )), + Filter::Value(ObTableValueFilter::new( + ObCompareOperator::LessThan, + "c3".to_string(), + 1, + )), + ], + )); batch_op.check_and_insert_up( vec![Value::from("Key_1"), Value::from("subKey_1")], vec!["c2".to_owned()], vec![Value::from("updateValue_1")], - Box::new(filter_1), + filter_1, true, ); - let filter_1 = filter_list!( + let filter_1 = Filter::List(ObTableFilterList::new( FilterOp::And, - ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "batchValue_1"), - ); + vec![Filter::Value(ObTableValueFilter::new( + ObCompareOperator::Equal, + "c2".to_string(), + "batchValue_1", + ))], + )); batch_op.check_and_insert_up( vec![Value::from("Key_2"), Value::from("subKey_2")], vec!["c2".to_owned()], vec![Value::from("updateValue_2")], - Box::new(filter_1), + filter_1, true, ); - let filter_1 = filter_list!( + let filter_1 = Filter::List(ObTableFilterList::new( FilterOp::And, - ObTableValueFilter::new(ObCompareOperator::Equal, "c2", "batchValue_3"), - ObTableValueFilter::new(ObCompareOperator::GreaterOrEqualThan, "c3", 1), - ); + vec![ + Filter::Value(ObTableValueFilter::new( + ObCompareOperator::Equal, + "c2".to_string(), + "batchValue_3", + )), + Filter::Value(ObTableValueFilter::new( + ObCompareOperator::GreaterOrEqualThan, + "c3".to_string(), + 1, + )), + ], + )); batch_op.check_and_insert_up( vec![Value::from("Key_3"), Value::from("subKey_3")], vec!["c2".to_owned()], vec![Value::from("updateValue_3")], - Box::new(filter_1), + filter_1, true, ); batch_op.set_atomic_op(false);