rust/greptimedb
1
0
Fork 0
mirror of https://github.com/GreptimeTeam/greptimedb.git synced 2026-05-27 10:20:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

build: bump rust edition to 2024 (#6920)

Browse Source 
* bump edition

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* format

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* gen keyword

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* lifetime and env var

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* one more gen fix

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* lifetime of temporaries in tail expressions

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* format again

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* clippy nested if

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* clippy let and return

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

---------

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>
This commit is contained in:
Ruihang Xia
2025-09-07 19:37:18 -07:00
committed by GitHub
parent 658d07bfc8
commit c9377e7c5a
1014 changed files with 6268 additions and 5540 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/common/function/src/admin/flush_compact_table.rs
View File

@@ -14,7 +14,7 @@
use std::str::FromStr;
use api::v1::region::{compact_request, StrictWindow};
use api::v1::region::{StrictWindow, compact_request};
use arrow::datatypes::DataType as ArrowDataType;
use common_error::ext::BoxedError;
use common_macro::admin_fn;
@@ -27,7 +27,7 @@ use datafusion_expr::{Signature, Volatility};
use datatypes::prelude::*;
use session::context::QueryContextRef;
use session::table_name::table_name_to_full_name;
use snafu::{ensure, ResultExt};
use snafu::{ResultExt, ensure};
use table::requests::{CompactTableRequest, FlushTableRequest};
use crate::handlers::TableMutationHandlerRef;
@@ -133,13 +133,19 @@ fn parse_compact_params(
table_name,
compact_request::Options::Regular(Default::default()),
),
[ValueRef::String(table_name), ValueRef::String(compact_ty_str)] => {
[
ValueRef::String(table_name),
ValueRef::String(compact_ty_str),
] => {
let compact_type = parse_compact_type(compact_ty_str, None)?;
(table_name, compact_type)
}
[ValueRef::String(table_name), ValueRef::String(compact_ty_str), ValueRef::String(options_str)] =>
{
[
ValueRef::String(table_name),
ValueRef::String(compact_ty_str),
ValueRef::String(options_str),
] => {
let compact_type = parse_compact_type(compact_ty_str, Some(options_str))?;
(table_name, compact_type)
}
@@ -148,7 +154,7 @@ fn parse_compact_params(
function: "compact_table",
datatypes: params.iter().map(|v| v.data_type()).collect::<Vec<_>>(),
}
.fail()
.fail();
}
};
@@ -384,22 +390,26 @@ mod tests {
),
]);
assert!(parse_compact_params(
&["table", "strict_window", "abc"]
.into_iter()
.map(ValueRef::String)
.collect::<Vec<_>>(),
&QueryContext::arc(),
)
.is_err());
assert!(
parse_compact_params(
&["table", "strict_window", "abc"]
.into_iter()
.map(ValueRef::String)
.collect::<Vec<_>>(),
&QueryContext::arc(),
)
.is_err()
);
assert!(parse_compact_params(
&["a.b.table", "strict_window", "abc"]
.into_iter()
.map(ValueRef::String)
.collect::<Vec<_>>(),
&QueryContext::arc(),
)
.is_err());
assert!(
parse_compact_params(
&["a.b.table", "strict_window", "abc"]
.into_iter()
.map(ValueRef::String)
.collect::<Vec<_>>(),
&QueryContext::arc(),
)
.is_err()
);
}
}

9
src/common/function/src/admin/reconcile_table.rs
View File

@@ -54,15 +54,16 @@ pub(crate) async fn reconcile_table(
) -> Result<Value> {
let (table_name, resolve_strategy) = match params {
[ValueRef::String(table_name)] => (table_name, ResolveStrategy::UseLatest),
[ValueRef::String(table_name), ValueRef::String(resolve_strategy)] => {
(table_name, parse_resolve_strategy(resolve_strategy)?)
}
[
ValueRef::String(table_name),
ValueRef::String(resolve_strategy),
] => (table_name, parse_resolve_strategy(resolve_strategy)?),
_ => {
return UnsupportedInputDataTypeSnafu {
function: FN_NAME,
datatypes: params.iter().map(|v| v.data_type()).collect::<Vec<_>>(),
}
.fail()
.fail();
}
};
let (catalog_name, schema_name, table_name) = table_name_to_full_name(table_name, query_ctx)

7
src/common/function/src/aggrs/aggr_wrapper.rs
View File

@@ -28,8 +28,8 @@ use arrow::array::StructArray;
use arrow_schema::{FieldRef, Fields};
use common_telemetry::debug;
use datafusion::functions_aggregate::all_default_aggregate_functions;
use datafusion::optimizer::analyzer::type_coercion::TypeCoercion;
use datafusion::optimizer::AnalyzerRule;
use datafusion::optimizer::analyzer::type_coercion::TypeCoercion;
use datafusion::physical_planner::create_aggregate_expr_and_maybe_filter;
use datafusion_common::{Column, ScalarValue};
use datafusion_expr::expr::{AggregateFunction, AggregateFunctionParams};
@@ -207,8 +207,9 @@ impl StateMergeHelper {
let upper_plan = LogicalPlan::Aggregate(upper_check).recompute_schema()?;
if *upper_plan.schema() != *aggr_plan.schema() {
return Err(datafusion_common::DataFusionError::Internal(format!(
"Upper aggregate plan's schema is not the same as the original aggregate plan's schema: \n[transformed]:{}\n[original]:{}",
upper_plan.schema(), aggr_plan.schema()
"Upper aggregate plan's schema is not the same as the original aggregate plan's schema: \n[transformed]:{}\n[original]:{}",
upper_plan.schema(),
aggr_plan.schema()
)));
}

86
src/common/function/src/aggrs/aggr_wrapper/tests.rs
View File

@@ -25,8 +25,8 @@ use datafusion::datasource::DefaultTableSource;
use datafusion::execution::{RecordBatchStream, SendableRecordBatchStream, TaskContext};
use datafusion::functions_aggregate::average::avg_udaf;
use datafusion::functions_aggregate::sum::sum_udaf;
use datafusion::optimizer::analyzer::type_coercion::TypeCoercion;
use datafusion::optimizer::AnalyzerRule;
use datafusion::optimizer::analyzer::type_coercion::TypeCoercion;
use datafusion::physical_plan::aggregates::AggregateExec;
use datafusion::physical_plan::execution_plan::{Boundedness, EmissionType};
use datafusion::physical_plan::{DisplayAs, DisplayFormatType, ExecutionPlan, PlanProperties};
@@ -35,7 +35,7 @@ use datafusion::prelude::SessionContext;
use datafusion_common::{Column, TableReference};
use datafusion_expr::expr::AggregateFunction;
use datafusion_expr::sqlparser::ast::NullTreatment;
use datafusion_expr::{lit, Aggregate, Expr, LogicalPlan, SortExpr, TableScan};
use datafusion_expr::{Aggregate, Expr, LogicalPlan, SortExpr, TableScan, lit};
use datafusion_physical_expr::aggregate::AggregateExprBuilder;
use datafusion_physical_expr::{EquivalenceProperties, Partitioning};
use datatypes::arrow_array::StringArray;
@@ -264,36 +264,38 @@ async fn test_sum_udaf() {
Aggregate::try_new(
Arc::new(expected_lower_plan),
vec![],
vec![Expr::AggregateFunction(AggregateFunction::new_udf(
Arc::new(
MergeWrapper::new(
sum.clone(),
Arc::new(
AggregateExprBuilder::new(
Arc::new(sum.clone()),
vec![Arc::new(
datafusion::physical_expr::expressions::Column::new(
"number", 0,
),
)],
)
.schema(Arc::new(dummy_table_scan().schema().as_arrow().clone()))
.alias("sum(number)")
.build()
.unwrap(),
),
vec![DataType::Int64],
)
.unwrap()
.into(),
),
vec![Expr::Column(Column::new_unqualified("__sum_state(number)"))],
false,
None,
vec![],
None,
))
.alias("sum(number)")],
vec![
Expr::AggregateFunction(AggregateFunction::new_udf(
Arc::new(
MergeWrapper::new(
sum.clone(),
Arc::new(
AggregateExprBuilder::new(
Arc::new(sum.clone()),
vec![Arc::new(
datafusion::physical_expr::expressions::Column::new(
"number", 0,
),
)],
)
.schema(Arc::new(dummy_table_scan().schema().as_arrow().clone()))
.alias("sum(number)")
.build()
.unwrap(),
),
vec![DataType::Int64],
)
.unwrap()
.into(),
),
vec![Expr::Column(Column::new_unqualified("__sum_state(number)"))],
false,
None,
vec![],
None,
))
.alias("sum(number)"),
],
)
.unwrap(),
);
@@ -444,15 +446,17 @@ async fn test_avg_udaf() {
Aggregate::try_new(
Arc::new(coerced_aggr_state_plan.clone()),
vec![],
vec![Expr::AggregateFunction(AggregateFunction::new_udf(
Arc::new(expected_merge_fn.into()),
vec![Expr::Column(Column::new_unqualified("__avg_state(number)"))],
false,
None,
vec![],
None,
))
.alias("avg(number)")],
vec![
Expr::AggregateFunction(AggregateFunction::new_udf(
Arc::new(expected_merge_fn.into()),
vec![Expr::Column(Column::new_unqualified("__avg_state(number)"))],
false,
None,
vec![],
None,
))
.alias("avg(number)"),
],
)
.unwrap(),
);

10
src/common/function/src/aggrs/approximate/hll.rs
View File

@@ -105,10 +105,10 @@ impl HllState {
}
fn merge(&mut self, raw: &[u8]) {
if let Ok(serialized) = bincode::deserialize::<HllStateType>(raw) {
if let Ok(()) = self.hll.merge(&serialized) {
return;
}
if let Ok(serialized) = bincode::deserialize::<HllStateType>(raw)
&& let Ok(()) = self.hll.merge(&serialized)
{
return;
}
trace!("Warning: Failed to merge HyperLogLog from {:?}", raw);
}
@@ -153,7 +153,7 @@ impl DfAccumulator for HllState {
return not_impl_err!(
"HLL functions do not support data type: {}",
array.data_type()
)
);
}
}

14
src/common/function/src/aggrs/approximate/uddsketch.rs
View File

@@ -98,11 +98,11 @@ impl UddSketchState {
{
return Err(DataFusionError::Plan(format!(
"Merging UDDSketch with different parameters: arguments={:?} vs actual input={:?}",
(self.uddsketch.max_allowed_buckets(), self.error_rate),
(
self.uddsketch.max_allowed_buckets(),
self.error_rate
),
(uddsketch.uddsketch.max_allowed_buckets(), uddsketch.error_rate)
uddsketch.uddsketch.max_allowed_buckets(),
uddsketch.error_rate
)
)));
}
self.uddsketch.merge_sketch(&uddsketch.uddsketch);
@@ -130,7 +130,7 @@ fn downcast_accumulator_args(args: AccumulatorArgs) -> DfResult<(u64, f64)> {
"{} not supported for bucket size: {}",
UDDSKETCH_STATE_NAME,
&args.exprs[0]
)
);
}
};
@@ -145,7 +145,7 @@ fn downcast_accumulator_args(args: AccumulatorArgs) -> DfResult<(u64, f64)> {
"{} not supported for error rate: {}",
UDDSKETCH_STATE_NAME,
&args.exprs[1]
)
);
}
};
@@ -168,7 +168,7 @@ impl DfAccumulator for UddSketchState {
return not_impl_err!(
"UDDSketch functions do not support data type: {}",
array.data_type()
)
);
}
}

4
src/common/function/src/aggrs/count_hash.rs
View File

@@ -28,9 +28,9 @@ use datafusion_common::cast::as_list_array;
use datafusion_common::error::Result;
use datafusion_common::hash_utils::create_hashes;
use datafusion_common::utils::SingleRowListArrayBuilder;
use datafusion_common::{internal_err, not_impl_err, ScalarValue};
use datafusion_common::{ScalarValue, internal_err, not_impl_err};
use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};
use datafusion_expr::utils::{format_state_name, AggregateOrderSensitivity};
use datafusion_expr::utils::{AggregateOrderSensitivity, format_state_name};
use datafusion_expr::{
Accumulator, AggregateUDF, AggregateUDFImpl, EmitTo, GroupsAccumulator, ReversedUDAF,
SetMonotonicity, Signature, TypeSignature, Volatility,

2
src/common/function/src/aggrs/geo/encoding.rs
View File

@@ -20,8 +20,8 @@ use datafusion::common::cast::as_primitive_array;
use datafusion::error::{DataFusionError, Result as DfResult};
use datafusion::logical_expr::{Accumulator as DfAccumulator, AggregateUDF, Volatility};
use datafusion::prelude::create_udaf;
use datafusion_common::cast::{as_list_array, as_struct_array};
use datafusion_common::ScalarValue;
use datafusion_common::cast::{as_list_array, as_struct_array};
use datatypes::arrow::array::{Float64Array, Int64Array, ListArray, StructArray};
use datatypes::arrow::datatypes::{
DataType, Field, Float64Type, Int64Type, TimeUnit, TimestampNanosecondType,

2
src/common/function/src/aggrs/geo/geo_path.rs
View File

@@ -19,9 +19,9 @@ use datafusion::common::cast::as_primitive_array;
use datafusion::error::{DataFusionError, Result as DfResult};
use datafusion::logical_expr::{Accumulator as DfAccumulator, AggregateUDF, Volatility};
use datafusion::prelude::create_udaf;
use datafusion_common::ScalarValue;
use datafusion_common::cast::{as_list_array, as_struct_array};
use datafusion_common::utils::SingleRowListArrayBuilder;
use datafusion_common::ScalarValue;
use datatypes::arrow::array::{Float64Array, Int64Array, ListArray, StructArray};
use datatypes::arrow::datatypes::{
DataType, Field, Float64Type, Int64Type, TimeUnit, TimestampNanosecondType,

14
src/common/function/src/aggrs/vector/product.rs
View File

@@ -101,7 +101,7 @@ impl VectorProduct {
return Err(datafusion_common::DataFusionError::NotImplemented(format!(
"unsupported data type {} for `VEC_PRODUCT`",
values[0].data_type()
)))
)));
}
};
if vectors.len() != values[0].len() {
@@ -208,11 +208,13 @@ mod tests {
// test update with constant vector
let mut vec_product = VectorProduct::default();
let v: Vec<ArrayRef> = vec![Arc::new(ConstantVector::new(
Arc::new(StringVector::from_vec(vec!["[1.0,2.0,3.0]".to_string()])),
4,
))
.to_arrow_array()];
let v: Vec<ArrayRef> = vec![
Arc::new(ConstantVector::new(
Arc::new(StringVector::from_vec(vec!["[1.0,2.0,3.0]".to_string()])),
4,
))
.to_arrow_array(),
];
vec_product.update_batch(&v).unwrap();

14
src/common/function/src/aggrs/vector/sum.rs
View File

@@ -117,7 +117,7 @@ impl VectorSum {
return Err(datafusion_common::DataFusionError::NotImplemented(format!(
"unsupported data type {} for `VEC_SUM`",
values[0].data_type()
)))
)));
}
}
Ok(())
@@ -212,11 +212,13 @@ mod tests {
// test update with constant vector
let mut vec_sum = VectorSum::default();
let v: Vec<ArrayRef> = vec![Arc::new(ConstantVector::new(
Arc::new(StringVector::from_vec(vec!["[1.0,2.0,3.0]".to_string()])),
4,
))
.to_arrow_array()];
let v: Vec<ArrayRef> = vec![
Arc::new(ConstantVector::new(
Arc::new(StringVector::from_vec(vec!["[1.0,2.0,3.0]".to_string()])),
4,
))
.to_arrow_array(),
];
vec_sum.update_batch(&v).unwrap();
assert_eq!(
ScalarValue::Binary(Some(veclit_to_binlit(&[4.0, 8.0, 12.0]))),

4
src/common/function/src/flush_flow.rs
View File

@@ -22,7 +22,7 @@ use common_query::error::{
use datafusion_expr::{Signature, Volatility};
use datatypes::value::{Value, ValueRef};
use session::context::QueryContextRef;
use snafu::{ensure, ResultExt};
use snafu::{ResultExt, ensure};
use sql::ast::ObjectNamePartExt;
use sql::parser::ParserContext;
@@ -91,7 +91,7 @@ fn parse_flush_flow(
obj_name
),
}
.fail()
.fail();
}
};
Ok((catalog_name, flow_name))

6
src/common/function/src/handlers.rs
View File

@@ -22,8 +22,8 @@ use common_meta::rpc::procedure::{
AddRegionFollowerRequest, MigrateRegionRequest, ProcedureStateResponse,
RemoveRegionFollowerRequest,
};
use common_query::error::Result;
use common_query::Output;
use common_query::error::Result;
use session::context::QueryContextRef;
use store_api::storage::RegionId;
use table::requests::{CompactTableRequest, DeleteRequest, FlushTableRequest, InsertRequest};
@@ -39,7 +39,7 @@ pub trait TableMutationHandler: Send + Sync {
/// Trigger a flush task for table.
async fn flush(&self, request: FlushTableRequest, ctx: QueryContextRef)
-> Result<AffectedRows>;
-> Result<AffectedRows>;
/// Trigger a compaction task for table.
async fn compact(
@@ -50,7 +50,7 @@ pub trait TableMutationHandler: Send + Sync {
/// Trigger a flush task for a table region.
async fn flush_region(&self, region_id: RegionId, ctx: QueryContextRef)
-> Result<AffectedRows>;
-> Result<AffectedRows>;
/// Trigger a compaction task for a table region.
async fn compact_region(

2
src/common/function/src/scalars/date/date_add.rs
View File

@@ -20,7 +20,7 @@ use datatypes::arrow::compute::kernels::numeric;
use datatypes::arrow::datatypes::{DataType, IntervalUnit, TimeUnit};
use datatypes::prelude::ConcreteDataType;
use datatypes::vectors::{Helper, VectorRef};
use snafu::{ensure, ResultExt};
use snafu::{ResultExt, ensure};
use crate::function::{Function, FunctionContext};
use crate::helper;

2
src/common/function/src/scalars/date/date_format.rs
View File

@@ -20,7 +20,7 @@ use datafusion_expr::Signature;
use datatypes::arrow::datatypes::{DataType, TimeUnit};
use datatypes::prelude::{ConcreteDataType, MutableVector, ScalarVectorBuilder};
use datatypes::vectors::{StringVectorBuilder, VectorRef};
use snafu::{ensure, ResultExt};
use snafu::{ResultExt, ensure};
use crate::function::{Function, FunctionContext};
use crate::helper;

2
src/common/function/src/scalars/date/date_sub.rs
View File

@@ -20,7 +20,7 @@ use datatypes::arrow::compute::kernels::numeric;
use datatypes::arrow::datatypes::{DataType, IntervalUnit, TimeUnit};
use datatypes::prelude::ConcreteDataType;
use datatypes::vectors::{Helper, VectorRef};
use snafu::{ensure, ResultExt};
use snafu::{ResultExt, ensure};
use crate::function::{Function, FunctionContext};
use crate::helper;

2
src/common/function/src/scalars/expression/ctx.rs
View File

@@ -13,8 +13,8 @@
// limitations under the License.
use common_query::error::Error;
use common_time::timezone::get_timezone;
use common_time::Timezone;
use common_time::timezone::get_timezone;
pub struct EvalContext {
pub timezone: Timezone,

2
src/common/function/src/scalars/expression/is_null.rs
View File

@@ -24,7 +24,7 @@ use datafusion_expr::{Signature, Volatility};
use datatypes::data_type::ConcreteDataType;
use datatypes::prelude::VectorRef;
use datatypes::vectors::Helper;
use snafu::{ensure, ResultExt};
use snafu::{ResultExt, ensure};
use crate::function::{Function, FunctionContext};

2
src/common/function/src/scalars/geo/geohash.rs
View File

@@ -25,7 +25,7 @@ use datatypes::scalars::{Scalar, ScalarVectorBuilder};
use datatypes::value::{ListValue, Value};
use datatypes::vectors::{ListVectorBuilder, MutableVector, StringVectorBuilder, VectorRef};
use geohash::Coord;
use snafu::{ensure, ResultExt};
use snafu::{ResultExt, ensure};
use crate::function::{Function, FunctionContext};

12
src/common/function/src/scalars/geo/h3.rs
View File

@@ -26,7 +26,7 @@ use datatypes::scalars::{Scalar, ScalarVectorBuilder};
use datatypes::value::{ListValue, Value};
use datatypes::vectors::{
BooleanVectorBuilder, Float64VectorBuilder, Int32VectorBuilder, ListVectorBuilder,
MutableVector, StringVectorBuilder, UInt64VectorBuilder, UInt8VectorBuilder, VectorRef,
MutableVector, StringVectorBuilder, UInt8VectorBuilder, UInt64VectorBuilder, VectorRef,
};
use derive_more::Display;
use h3o::{CellIndex, LatLng, Resolution};
@@ -967,11 +967,11 @@ impl Function for H3CellContains {
// get cell resolution, and find cell_this's parent at
// this solution, test if cell_that equals the parent
let resolution = cell_that.resolution();
if let Some(cell_this_parent) = cell_this.parent(resolution) {
if cell_this_parent == *cell_that {
result = Some(true);
break;
}
if let Some(cell_this_parent) = cell_this.parent(resolution)
&& cell_this_parent == *cell_that
{
result = Some(true);
break;
}
}
}

10
src/common/function/src/scalars/hll_count.rs
View File

@@ -160,10 +160,12 @@ mod tests {
let args: Vec<VectorRef> = vec![];
let result = function.eval(&FunctionContext::default(), &args);
assert!(result.is_err());
assert!(result
.unwrap_err()
.to_string()
.contains("hll_count expects 1 argument"));
assert!(
result
.unwrap_err()
.to_string()
.contains("hll_count expects 1 argument")
);
// Test with invalid binary data
let args: Vec<VectorRef> = vec![Arc::new(BinaryVector::from(vec![Some(vec![1, 2, 3])]))]; // Invalid binary data

2
src/common/function/src/scalars/json/json_to_string.rs
View File

@@ -78,7 +78,7 @@ impl Function for JsonToStringFunction {
return InvalidFuncArgsSnafu {
err_msg: format!("Illegal json binary: {:?}", json),
}
.fail()
.fail();
}
},
_ => None,

2
src/common/function/src/scalars/json/parse_json.rs
View File

@@ -75,7 +75,7 @@ impl Function for ParseJsonFunction {
json_string
),
}
.fail()
.fail();
}
},
_ => None,

17
src/common/function/src/scalars/matches.rs
View File

@@ -29,7 +29,7 @@ use datatypes::arrow::array::RecordBatch;
use datatypes::arrow::datatypes::{DataType, Field};
use datatypes::prelude::VectorRef;
use datatypes::vectors::BooleanVector;
use snafu::{ensure, OptionExt, ResultExt};
use snafu::{OptionExt, ResultExt, ensure};
use store_api::storage::ConcreteDataType;
use crate::function::{Function, FunctionContext};
@@ -751,13 +751,13 @@ impl Tokenizer {
let phase = self.consume_next_phase(true, pattern)?;
tokens.push(Token::Phase(phase));
// consume a writespace (or EOF) after quotes
if let Some(ending_separator) = self.consume_next(pattern) {
if ending_separator != ' ' {
return InvalidFuncArgsSnafu {
err_msg: "Expect a space after quotes ('\"')",
}
.fail();
if let Some(ending_separator) = self.consume_next(pattern)
&& ending_separator != ' '
{
return InvalidFuncArgsSnafu {
err_msg: "Expect a space after quotes ('\"')",
}
.fail();
}
}
_ => {
@@ -776,8 +776,7 @@ impl Tokenizer {
fn consume_next(&mut self, pattern: &str) -> Option<char> {
self.cursor += 1;
let c = pattern.chars().nth(self.cursor);
c
pattern.chars().nth(self.cursor)
}
fn step_next(&mut self) {

4
src/common/function/src/scalars/math/clamp.rs
View File

@@ -18,15 +18,15 @@ use std::sync::Arc;
use common_query::error::{InvalidFuncArgsSnafu, Result};
use datafusion::arrow::array::{ArrayIter, PrimitiveArray};
use datafusion::logical_expr::Volatility;
use datafusion_expr::type_coercion::aggregates::NUMERICS;
use datafusion_expr::Signature;
use datafusion_expr::type_coercion::aggregates::NUMERICS;
use datatypes::data_type::{ConcreteDataType, DataType};
use datatypes::prelude::VectorRef;
use datatypes::types::LogicalPrimitiveType;
use datatypes::value::TryAsPrimitive;
use datatypes::vectors::PrimitiveVector;
use datatypes::with_match_primitive_type_id;
use snafu::{ensure, OptionExt};
use snafu::{OptionExt, ensure};
use crate::function::{Function, FunctionContext};

2
src/common/function/src/scalars/math/modulo.rs
View File

@@ -24,7 +24,7 @@ use datatypes::arrow::compute::kernels::numeric;
use datatypes::arrow::datatypes::DataType as ArrowDataType;
use datatypes::prelude::ConcreteDataType;
use datatypes::vectors::{Helper, VectorRef};
use snafu::{ensure, ResultExt};
use snafu::{ResultExt, ensure};
use crate::function::{Function, FunctionContext};

2
src/common/function/src/scalars/test.rs
View File

@@ -22,7 +22,7 @@ use datatypes::data_type::ConcreteDataType;
use datatypes::prelude::VectorRef;
use crate::function::{Function, FunctionContext};
use crate::scalars::expression::{scalar_binary_op, EvalContext};
use crate::scalars::expression::{EvalContext, scalar_binary_op};
#[derive(Clone, Default)]
pub(crate) struct TestAndFunction;

10
src/common/function/src/scalars/uddsketch_calc.rs
View File

@@ -198,10 +198,12 @@ mod tests {
let args: Vec<VectorRef> = vec![Arc::new(Float64Vector::from_vec(vec![0.95]))];
let result = function.eval(&FunctionContext::default(), &args);
assert!(result.is_err());
assert!(result
.unwrap_err()
.to_string()
.contains("uddsketch_calc expects 2 arguments"));
assert!(
result
.unwrap_err()
.to_string()
.contains("uddsketch_calc expects 2 arguments")
);
// Test with invalid binary data
let args: Vec<VectorRef> = vec![

2
src/common/function/src/scalars/vector/convert/parse_vector.rs
View File

@@ -20,7 +20,7 @@ use datatypes::prelude::ConcreteDataType;
use datatypes::scalars::ScalarVectorBuilder;
use datatypes::types::parse_string_to_vector_type_value;
use datatypes::vectors::{BinaryVectorBuilder, MutableVector, VectorRef};
use snafu::{ensure, ResultExt};
use snafu::{ResultExt, ensure};
use crate::function::{Function, FunctionContext};

6
src/common/function/src/scalars/vector/distance/cos.rs
View File

@@ -33,11 +33,7 @@ pub fn cos(lhs: &[f32], rhs: &[f32]) -> f32 {
let cos_similar = dot_product / (lhs_norm * rhs_norm);
let res = 1.0 - cos_similar;
if res.abs() < f32::EPSILON {
0.0
} else {
res
}
if res.abs() < f32::EPSILON { 0.0 } else { res }
}
#[cfg(test)]

2
src/common/function/src/state.rs
View File

@@ -40,8 +40,8 @@ impl FunctionState {
AddRegionFollowerRequest, MigrateRegionRequest, ProcedureStateResponse,
RemoveRegionFollowerRequest,
};
use common_query::error::Result;
use common_query::Output;
use common_query::error::Result;
use session::context::QueryContextRef;
use store_api::storage::RegionId;
use table::requests::{

2
src/common/function/src/system/pg_catalog/pg_get_userbyid.rs
View File

@@ -23,7 +23,7 @@ use datatypes::with_match_primitive_type_id;
use num_traits::AsPrimitive;
use crate::function::{Function, FunctionContext};
use crate::scalars::expression::{scalar_unary_op, EvalContext};
use crate::scalars::expression::{EvalContext, scalar_unary_op};
#[derive(Clone, Debug, Default)]
pub struct PGGetUserByIdFunction;

2
src/common/function/src/system/pg_catalog/table_is_visible.rs
View File

@@ -23,7 +23,7 @@ use datatypes::with_match_primitive_type_id;
use num_traits::AsPrimitive;
use crate::function::{Function, FunctionContext};
use crate::scalars::expression::{scalar_unary_op, EvalContext};
use crate::scalars::expression::{EvalContext, scalar_unary_op};
#[derive(Clone, Debug, Default)]
pub struct PGTableIsVisibleFunction;