Skip to content

Commit d2be911

Browse files
BohuTANGBohuTANG
authored
Merge pull request #10712 from andylokandy/noliteral
refactor(expr): remove Literal
2 parents 7405546 + 2eeed16 commit d2be911

File tree

41 files changed

+735
-997
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

41 files changed

+735
-997
lines changed

‎src/query/expression/src/expression.rs‎

Lines changed: 4 additions & 97 deletions
Original file line numberDiff line numberDiff line change
@@ -17,23 +17,15 @@ use std::fmt::Debug;
1717
use std::hash::Hash;
1818
use std::sync::Arc;
1919

20-
use common_exception::ErrorCode;
21-
use common_exception::Result;
2220
use common_exception::Span;
2321
use educe::Educe;
2422
use enum_as_inner::EnumAsInner;
25-
use ethnum::i256;
2623
use serde::Deserialize;
2724
use serde::Serialize;
2825

2926
use crate::function::Function;
3027
use crate::function::FunctionID;
3128
use crate::function::FunctionRegistry;
32-
use crate::types::decimal::DecimalScalar;
33-
use crate::types::decimal::DecimalSize;
34-
use crate::types::number::NumberScalar;
35-
use crate::types::number::F32;
36-
use crate::types::number::F64;
3729
use crate::types::DataType;
3830
use crate::values::Scalar;
3931

@@ -47,9 +39,9 @@ impl ColumnIndex for String {}
4739
/// It can be type-checked and then converted to an evaluatable [`Expr`].
4840
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
4941
pub enum RawExpr<Index: ColumnIndex = usize> {
50-
Literal {
42+
Constant {
5143
span: Span,
52-
lit: Literal,
44+
scalar: Scalar,
5345
},
5446
ColumnRef {
5547
span: Span,
@@ -142,91 +134,6 @@ pub enum RemoteExpr<Index: ColumnIndex = usize> {
142134
},
143135
}
144136

145-
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, EnumAsInner)]
146-
pub enum Literal {
147-
Null,
148-
Int8(i8),
149-
Int16(i16),
150-
Int32(i32),
151-
Int64(i64),
152-
UInt8(u8),
153-
UInt16(u16),
154-
UInt32(u32),
155-
UInt64(u64),
156-
Float32(F32),
157-
Float64(F64),
158-
Decimal128 {
159-
value: i128,
160-
precision: u8,
161-
scale: u8,
162-
},
163-
Decimal256 {
164-
value: i256,
165-
precision: u8,
166-
scale: u8,
167-
},
168-
Boolean(bool),
169-
String(Vec<u8>),
170-
}
171-
172-
impl Literal {
173-
pub fn into_scalar(self) -> Scalar {
174-
match self {
175-
Literal::Null => Scalar::Null,
176-
Literal::Int8(value) => Scalar::Number(NumberScalar::Int8(value)),
177-
Literal::Int16(value) => Scalar::Number(NumberScalar::Int16(value)),
178-
Literal::Int32(value) => Scalar::Number(NumberScalar::Int32(value)),
179-
Literal::Int64(value) => Scalar::Number(NumberScalar::Int64(value)),
180-
Literal::UInt8(value) => Scalar::Number(NumberScalar::UInt8(value)),
181-
Literal::UInt16(value) => Scalar::Number(NumberScalar::UInt16(value)),
182-
Literal::UInt32(value) => Scalar::Number(NumberScalar::UInt32(value)),
183-
Literal::UInt64(value) => Scalar::Number(NumberScalar::UInt64(value)),
184-
Literal::Float32(value) => Scalar::Number(NumberScalar::Float32(value)),
185-
Literal::Decimal128 {
186-
value,
187-
precision,
188-
scale,
189-
} => Scalar::Decimal(DecimalScalar::Decimal128(value, DecimalSize {
190-
precision,
191-
scale,
192-
})),
193-
Literal::Decimal256 {
194-
value,
195-
precision,
196-
scale,
197-
} => Scalar::Decimal(DecimalScalar::Decimal256(value, DecimalSize {
198-
precision,
199-
scale,
200-
})),
201-
Literal::Float64(value) => Scalar::Number(NumberScalar::Float64(value)),
202-
Literal::Boolean(value) => Scalar::Boolean(value),
203-
Literal::String(value) => Scalar::String(value.to_vec()),
204-
}
205-
}
206-
}
207-
208-
impl TryFrom<Scalar> for Literal {
209-
type Error = ErrorCode;
210-
fn try_from(value: Scalar) -> Result<Self> {
211-
match value {
212-
Scalar::Null => Ok(Literal::Null),
213-
Scalar::Number(NumberScalar::Int8(value)) => Ok(Literal::Int8(value)),
214-
Scalar::Number(NumberScalar::Int16(value)) => Ok(Literal::Int16(value)),
215-
Scalar::Number(NumberScalar::Int32(value)) => Ok(Literal::Int32(value)),
216-
Scalar::Number(NumberScalar::Int64(value)) => Ok(Literal::Int64(value)),
217-
Scalar::Number(NumberScalar::UInt8(value)) => Ok(Literal::UInt8(value)),
218-
Scalar::Number(NumberScalar::UInt16(value)) => Ok(Literal::UInt16(value)),
219-
Scalar::Number(NumberScalar::UInt32(value)) => Ok(Literal::UInt32(value)),
220-
Scalar::Number(NumberScalar::UInt64(value)) => Ok(Literal::UInt64(value)),
221-
Scalar::Number(NumberScalar::Float32(value)) => Ok(Literal::Float32(value)),
222-
Scalar::Number(NumberScalar::Float64(value)) => Ok(Literal::Float64(value)),
223-
Scalar::Boolean(value) => Ok(Literal::Boolean(value)),
224-
Scalar::String(value) => Ok(Literal::String(value.to_vec())),
225-
_ => Err(ErrorCode::Internal("Unsupported scalar value")),
226-
}
227-
}
228-
}
229-
230137
impl<Index: ColumnIndex> RawExpr<Index> {
231138
pub fn column_refs(&self) -> HashMap<Index, DataType> {
232139
fn walk<Index: ColumnIndex>(expr: &RawExpr<Index>, buf: &mut HashMap<Index, DataType>) {
@@ -236,7 +143,7 @@ impl<Index: ColumnIndex> RawExpr<Index> {
236143
}
237144
RawExpr::Cast { expr, .. } => walk(expr, buf),
238145
RawExpr::FunctionCall { args, .. } => args.iter().for_each(|expr| walk(expr, buf)),
239-
RawExpr::Literal { .. } => (),
146+
RawExpr::Constant { .. } => (),
240147
}
241148
}
242149

@@ -247,7 +154,7 @@ impl<Index: ColumnIndex> RawExpr<Index> {
247154

248155
pub fn sql_display(&self) -> String {
249156
match self {
250-
RawExpr::Literal { lit, .. } => format!("{lit}"),
157+
RawExpr::Constant { scalar: lit, .. } => format!("{lit}"),
251158
RawExpr::ColumnRef { display_name, .. } => display_name.clone(),
252159
RawExpr::Cast {
253160
is_try,

‎src/query/expression/src/type_check.rs‎

Lines changed: 5 additions & 88 deletions
Original file line numberDiff line numberDiff line change
@@ -21,14 +21,10 @@ use common_exception::Span;
2121
use itertools::Itertools;
2222

2323
use crate::expression::Expr;
24-
use crate::expression::Literal;
2524
use crate::expression::RawExpr;
2625
use crate::function::FunctionRegistry;
2726
use crate::function::FunctionSignature;
28-
use crate::types::decimal::DecimalScalar;
2927
use crate::types::decimal::DecimalSize;
30-
use crate::types::number::NumberDataType;
31-
use crate::types::number::NumberScalar;
3228
use crate::types::DataType;
3329
use crate::types::DecimalDataType;
3430
use crate::types::Number;
@@ -43,14 +39,11 @@ pub fn check<Index: ColumnIndex>(
4339
fn_registry: &FunctionRegistry,
4440
) -> Result<Expr<Index>> {
4541
match ast {
46-
RawExpr::Literal { span, lit } => {
47-
let (scalar, data_type) = check_literal(lit);
48-
Ok(Expr::Constant {
49-
span: *span,
50-
scalar,
51-
data_type,
52-
})
53-
}
42+
RawExpr::Constant { span, scalar } => Ok(Expr::Constant {
43+
span: *span,
44+
scalar: scalar.clone(),
45+
data_type: scalar.as_ref().infer_data_type(),
46+
}),
5447
RawExpr::ColumnRef {
5548
span,
5649
id,
@@ -86,82 +79,6 @@ pub fn check<Index: ColumnIndex>(
8679
}
8780
}
8881

89-
pub fn check_literal(literal: &Literal) -> (Scalar, DataType) {
90-
match literal {
91-
Literal::Null => (Scalar::Null, DataType::Null),
92-
Literal::UInt8(v) => (
93-
Scalar::Number(NumberScalar::UInt8(*v)),
94-
DataType::Number(NumberDataType::UInt8),
95-
),
96-
Literal::UInt16(v) => (
97-
Scalar::Number(NumberScalar::UInt16(*v)),
98-
DataType::Number(NumberDataType::UInt16),
99-
),
100-
Literal::UInt32(v) => (
101-
Scalar::Number(NumberScalar::UInt32(*v)),
102-
DataType::Number(NumberDataType::UInt32),
103-
),
104-
Literal::UInt64(v) => (
105-
Scalar::Number(NumberScalar::UInt64(*v)),
106-
DataType::Number(NumberDataType::UInt64),
107-
),
108-
Literal::Int8(v) => (
109-
Scalar::Number(NumberScalar::Int8(*v)),
110-
DataType::Number(NumberDataType::Int8),
111-
),
112-
Literal::Int16(v) => (
113-
Scalar::Number(NumberScalar::Int16(*v)),
114-
DataType::Number(NumberDataType::Int16),
115-
),
116-
Literal::Int32(v) => (
117-
Scalar::Number(NumberScalar::Int32(*v)),
118-
DataType::Number(NumberDataType::Int32),
119-
),
120-
Literal::Int64(v) => (
121-
Scalar::Number(NumberScalar::Int64(*v)),
122-
DataType::Number(NumberDataType::Int64),
123-
),
124-
Literal::Decimal128 {
125-
value,
126-
precision,
127-
scale,
128-
} => {
129-
let size = DecimalSize {
130-
precision: *precision,
131-
scale: *scale,
132-
};
133-
(
134-
Scalar::Decimal(DecimalScalar::Decimal128(*value, size)),
135-
DataType::Decimal(DecimalDataType::Decimal128(size)),
136-
)
137-
}
138-
Literal::Decimal256 {
139-
value,
140-
precision,
141-
scale,
142-
} => {
143-
let size = DecimalSize {
144-
precision: *precision,
145-
scale: *scale,
146-
};
147-
(
148-
Scalar::Decimal(DecimalScalar::Decimal256(*value, size)),
149-
DataType::Decimal(DecimalDataType::Decimal256(size)),
150-
)
151-
}
152-
Literal::Float32(v) => (
153-
Scalar::Number(NumberScalar::Float32(*v)),
154-
DataType::Number(NumberDataType::Float32),
155-
),
156-
Literal::Float64(v) => (
157-
Scalar::Number(NumberScalar::Float64(*v)),
158-
DataType::Number(NumberDataType::Float64),
159-
),
160-
Literal::Boolean(v) => (Scalar::Boolean(*v), DataType::Boolean),
161-
Literal::String(v) => (Scalar::String(v.clone()), DataType::String),
162-
}
163-
}
164-
16582
pub fn check_cast<Index: ColumnIndex>(
16683
span: Span,
16784
is_try: bool,

‎src/query/expression/src/utils/display.rs‎

Lines changed: 1 addition & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,6 @@ use rust_decimal::RoundingStrategy;
2828

2929
use crate::block::DataBlock;
3030
use crate::expression::Expr;
31-
use crate::expression::Literal;
3231
use crate::expression::RawExpr;
3332
use crate::function::Function;
3433
use crate::function::FunctionSignature;
@@ -377,7 +376,7 @@ impl Debug for StringColumn {
377376
impl<Index: ColumnIndex> Display for RawExpr<Index> {
378377
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
379378
match self {
380-
RawExpr::Literal { lit, .. } => write!(f, "{lit}"),
379+
RawExpr::Constant { scalar, .. } => write!(f, "{scalar}"),
381380
RawExpr::ColumnRef {
382381
display_name,
383382
data_type,
@@ -424,48 +423,6 @@ impl<Index: ColumnIndex> Display for RawExpr<Index> {
424423
}
425424
}
426425

427-
impl Display for Literal {
428-
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
429-
match self {
430-
Literal::Null => write!(f, "NULL"),
431-
Literal::Boolean(val) => write!(f, "{val}"),
432-
Literal::Int8(val) => write!(f, "{val}_i8"),
433-
Literal::Int16(val) => write!(f, "{val}_i16"),
434-
Literal::Int32(val) => write!(f, "{val}_i32"),
435-
Literal::Int64(val) => write!(f, "{val}_i64"),
436-
Literal::UInt8(val) => write!(f, "{val}_u8"),
437-
Literal::UInt16(val) => write!(f, "{val}_u16"),
438-
Literal::UInt32(val) => write!(f, "{val}_u32"),
439-
Literal::UInt64(val) => write!(f, "{val}_u64"),
440-
Literal::Float32(val) => write!(f, "{val}_f32"),
441-
Literal::Float64(val) => write!(f, "{val}_f64"),
442-
Literal::Decimal256 {
443-
value,
444-
precision,
445-
scale,
446-
} => write!(
447-
f,
448-
"{}_decimal({}, {})",
449-
display_decimal_256(*value, *scale),
450-
precision,
451-
scale
452-
),
453-
Literal::Decimal128 {
454-
value,
455-
precision,
456-
scale,
457-
} => write!(
458-
f,
459-
"{}_decimal({}, {})",
460-
display_decimal_128(*value, *scale),
461-
precision,
462-
scale
463-
),
464-
Literal::String(val) => write!(f, "{:?}", String::from_utf8_lossy(val)),
465-
}
466-
}
467-
}
468-
469426
impl Display for DataType {
470427
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
471428
match &self {

‎src/query/expression/src/values.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -468,7 +468,7 @@ impl<'a> ScalarRef<'a> {
468468

469469
/// Infer the data type of the scalar.
470470
/// If the scalar is Null, the data type is `DataType::Null`,
471-
/// otherwise, the inferred data type is not nullable.
471+
/// otherwise, the inferred data type is non-nullable.
472472
pub fn infer_data_type(&self) -> DataType {
473473
match self {
474474
ScalarRef::Null => DataType::Null,

0 commit comments

Comments
 (0)