risingwave_frontend/binder/expr/
value.rs

1// Copyright 2022 RisingWave Labs
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use risingwave_common::bail_not_implemented;
16use risingwave_common::types::{
17    DataType, DateTimeField, Decimal, Interval, MapType, ScalarImpl, StructType,
18};
19use risingwave_sqlparser::ast::{DateTimeField as AstDateTimeField, Expr, Value};
20use thiserror_ext::AsReport;
21
22use crate::binder::Binder;
23use crate::error::{ErrorCode, Result};
24use crate::expr::{Expr as _, ExprImpl, ExprType, FunctionCall, Literal, align_types};
25
26impl Binder {
27    pub fn bind_value(&mut self, value: &Value) -> Result<Literal> {
28        match value {
29            Value::Number(s) => self.bind_number(s.clone()),
30            Value::SingleQuotedString(s) => self.bind_string(s),
31            Value::DollarQuotedString(s) => self.bind_string(&s.value),
32            Value::CstyleEscapedString(s) => self.bind_string(&s.value),
33            Value::Boolean(b) => self.bind_bool(*b),
34            // Both null and string literal will be treated as `unknown` during type inference.
35            // See [`ExprImpl::is_unknown`].
36            Value::Null => Ok(Literal::new_untyped(None)),
37            Value::Interval {
38                value,
39                leading_field,
40                // TODO: support more interval types.
41                leading_precision: None,
42                last_field: None,
43                fractional_seconds_precision: None,
44            } => self.bind_interval(value, *leading_field),
45            _ => bail_not_implemented!("value: {:?}", value),
46        }
47    }
48
49    pub(super) fn bind_string(&mut self, s: &str) -> Result<Literal> {
50        Ok(Literal::new_untyped(Some(s.to_owned())))
51    }
52
53    fn bind_bool(&mut self, b: bool) -> Result<Literal> {
54        Ok(Literal::new(Some(ScalarImpl::Bool(b)), DataType::Boolean))
55    }
56
57    fn bind_number(&mut self, mut s: String) -> Result<Literal> {
58        let prefix_start = match s.starts_with('-') {
59            true => 1,
60            false => 0,
61        };
62        let base = match prefix_start + 2 <= s.len() {
63            true => match &s[prefix_start..prefix_start + 2] {
64                // tokenizer already converts them to lowercase
65                "0x" => 16,
66                "0o" => 8,
67                "0b" => 2,
68                _ => 10,
69            },
70            false => 10,
71        };
72        if base != 10 {
73            s.replace_range(prefix_start..prefix_start + 2, "");
74        }
75
76        let (data, data_type) = if let Ok(int_32) = i32::from_str_radix(&s, base) {
77            (Some(ScalarImpl::Int32(int_32)), DataType::Int32)
78        } else if let Ok(int_64) = i64::from_str_radix(&s, base) {
79            (Some(ScalarImpl::Int64(int_64)), DataType::Int64)
80        } else if let Ok(decimal) = Decimal::from_str_radix(&s, base) {
81            // Notice: when the length of decimal exceeds 29(>= 30), it will be rounded up.
82            (Some(ScalarImpl::Decimal(decimal)), DataType::Decimal)
83        } else if let Some(scientific) = Decimal::from_scientific(&s) {
84            (Some(ScalarImpl::Decimal(scientific)), DataType::Decimal)
85        } else {
86            return Err(ErrorCode::BindError(format!("Number {s} overflows")).into());
87        };
88        Ok(Literal::new(data, data_type))
89    }
90
91    fn bind_interval(
92        &mut self,
93        s: &str,
94        leading_field: Option<AstDateTimeField>,
95    ) -> Result<Literal> {
96        let interval =
97            Interval::parse_with_fields(s, leading_field.map(Self::bind_date_time_field))
98                .map_err(|e| ErrorCode::BindError(e.to_report_string()))?;
99        let datum = Some(ScalarImpl::Interval(interval));
100        let literal = Literal::new(datum, DataType::Interval);
101
102        Ok(literal)
103    }
104
105    pub(crate) fn bind_date_time_field(field: AstDateTimeField) -> DateTimeField {
106        // This is a binder function rather than `impl From<AstDateTimeField> for DateTimeField`,
107        // so that the `sqlparser` crate and the `common` crate are kept independent.
108        match field {
109            AstDateTimeField::Year => DateTimeField::Year,
110            AstDateTimeField::Month => DateTimeField::Month,
111            AstDateTimeField::Day => DateTimeField::Day,
112            AstDateTimeField::Hour => DateTimeField::Hour,
113            AstDateTimeField::Minute => DateTimeField::Minute,
114            AstDateTimeField::Second => DateTimeField::Second,
115        }
116    }
117
118    /// `ARRAY[...]` is represented as an function call at the binder stage.
119    pub(super) fn bind_array(&mut self, exprs: &[Expr]) -> Result<ExprImpl> {
120        if exprs.is_empty() {
121            return Err(ErrorCode::BindError("cannot determine type of empty array\nHINT:  Explicitly cast to the desired type, for example ARRAY[]::integer[].".into()).into());
122        }
123        let mut exprs = exprs
124            .iter()
125            .map(|e| self.bind_expr_inner(e))
126            .collect::<Result<Vec<ExprImpl>>>()?;
127        let element_type = align_types(exprs.iter_mut())?;
128        let expr: ExprImpl =
129            FunctionCall::new_unchecked(ExprType::Array, exprs, DataType::list(element_type))
130                .into();
131        Ok(expr)
132    }
133
134    pub(super) fn bind_map(&mut self, entries: &[(Expr, Expr)]) -> Result<ExprImpl> {
135        if entries.is_empty() {
136            return Err(ErrorCode::BindError("cannot determine type of empty map\nHINT:  Explicitly cast to the desired type, for example MAP{}::map(int,int).".into()).into());
137        }
138        let mut keys = Vec::with_capacity(entries.len());
139        let mut values = Vec::with_capacity(entries.len());
140        for (k, v) in entries {
141            keys.push(self.bind_expr_inner(k)?);
142            values.push(self.bind_expr_inner(v)?);
143        }
144        let key_type = align_types(keys.iter_mut())?;
145        let value_type = align_types(values.iter_mut())?;
146
147        let keys: ExprImpl =
148            FunctionCall::new_unchecked(ExprType::Array, keys, DataType::list(key_type.clone()))
149                .into();
150        let values: ExprImpl = FunctionCall::new_unchecked(
151            ExprType::Array,
152            values,
153            DataType::list(value_type.clone()),
154        )
155        .into();
156
157        let expr: ExprImpl = FunctionCall::new_unchecked(
158            ExprType::MapFromKeyValues,
159            vec![keys, values],
160            DataType::Map(MapType::from_kv(key_type, value_type)),
161        )
162        .into();
163        Ok(expr)
164    }
165
166    pub(super) fn bind_array_cast(
167        &mut self,
168        exprs: &[Expr],
169        element_type: &DataType,
170    ) -> Result<ExprImpl> {
171        let exprs = exprs
172            .iter()
173            .map(|e| self.bind_cast_inner(e, element_type))
174            .collect::<Result<Vec<ExprImpl>>>()?;
175
176        let expr: ExprImpl = FunctionCall::new_unchecked(
177            ExprType::Array,
178            exprs,
179            DataType::list(element_type.clone()),
180        )
181        .into();
182        Ok(expr)
183    }
184
185    pub(super) fn bind_map_cast(
186        &mut self,
187        entries: &[(Expr, Expr)],
188        map_type: &MapType,
189    ) -> Result<ExprImpl> {
190        let mut keys = Vec::with_capacity(entries.len());
191        let mut values = Vec::with_capacity(entries.len());
192        for (k, v) in entries {
193            keys.push(self.bind_cast_inner(k, map_type.key())?);
194            values.push(self.bind_cast_inner(v, map_type.value())?);
195        }
196
197        let keys: ExprImpl = FunctionCall::new_unchecked(
198            ExprType::Array,
199            keys,
200            DataType::list(map_type.key().clone()),
201        )
202        .into();
203        let values: ExprImpl = FunctionCall::new_unchecked(
204            ExprType::Array,
205            values,
206            DataType::list(map_type.value().clone()),
207        )
208        .into();
209
210        let expr: ExprImpl = FunctionCall::new_unchecked(
211            ExprType::MapFromKeyValues,
212            vec![keys, values],
213            DataType::Map(map_type.clone()),
214        )
215        .into();
216        Ok(expr)
217    }
218
219    pub(super) fn bind_index(&mut self, obj: &Expr, index: &Expr) -> Result<ExprImpl> {
220        let obj = self.bind_expr_inner(obj)?;
221        match obj.return_type() {
222            DataType::List(l) => Ok(FunctionCall::new_unchecked(
223                ExprType::ArrayAccess,
224                vec![obj, self.bind_expr_inner(index)?],
225                l.into_elem(),
226            )
227            .into()),
228            DataType::Map(m) => Ok(FunctionCall::new_unchecked(
229                ExprType::MapAccess,
230                vec![obj, self.bind_expr_inner(index)?],
231                m.value().clone(),
232            )
233            .into()),
234            data_type => Err(ErrorCode::BindError(format!(
235                "index operator applied to type {}, which is not a list or map",
236                data_type
237            ))
238            .into()),
239        }
240    }
241
242    pub(super) fn bind_array_range_index(
243        &mut self,
244        obj: &Expr,
245        start: Option<&Expr>,
246        end: Option<&Expr>,
247    ) -> Result<ExprImpl> {
248        let obj = self.bind_expr_inner(obj)?;
249        let start = match start {
250            None => ExprImpl::literal_int(1),
251            Some(expr) => self
252                .bind_expr_inner(expr)?
253                .cast_implicit(&DataType::Int32)?,
254        };
255        // Don't worry, the backend implementation will stop iterating once it encounters the end
256        // of the array.
257        let end = match end {
258            None => ExprImpl::literal_int(i32::MAX),
259            Some(expr) => self
260                .bind_expr_inner(expr)?
261                .cast_implicit(&DataType::Int32)?,
262        };
263        match obj.return_type() {
264            t @ DataType::List(_) => Ok(FunctionCall::new_unchecked(
265                ExprType::ArrayRangeAccess,
266                vec![obj, start, end],
267                t,
268            )
269            .into()),
270            data_type => Err(ErrorCode::BindError(format!(
271                "array range index applied to type {}, which is not a list",
272                data_type
273            ))
274            .into()),
275        }
276    }
277
278    /// `Row(...)` is represented as an function call at the binder stage.
279    pub(super) fn bind_row(&mut self, exprs: &[Expr]) -> Result<ExprImpl> {
280        let exprs = exprs
281            .iter()
282            .map(|e| self.bind_expr_inner(e))
283            .collect::<Result<Vec<ExprImpl>>>()?;
284        let data_type = StructType::row_expr_type(exprs.iter().map(|e| e.return_type())).into();
285        let expr: ExprImpl = FunctionCall::new_unchecked(ExprType::Row, exprs, data_type).into();
286        Ok(expr)
287    }
288}
289
290#[cfg(test)]
291mod tests {
292    use risingwave_common::types::test_utils::IntervalTestExt;
293    use risingwave_expr::expr::build_from_prost;
294    use risingwave_sqlparser::ast::Value::Number;
295
296    use super::*;
297    use crate::binder::test_utils::mock_binder;
298    use crate::expr::Expr;
299
300    #[tokio::test]
301    async fn test_bind_value() {
302        use std::str::FromStr;
303
304        let mut binder = mock_binder();
305        let values = [
306            "1",
307            "111111111111111",
308            "111111111.111111",
309            "111111111111111111111111",
310            "0.111111",
311            "-0.01",
312        ];
313        let data = [
314            Some(ScalarImpl::Int32(1)),
315            Some(ScalarImpl::Int64(111111111111111)),
316            Some(ScalarImpl::Decimal(
317                Decimal::from_str("111111111.111111").unwrap(),
318            )),
319            Some(ScalarImpl::Decimal(
320                Decimal::from_str("111111111111111111111111").unwrap(),
321            )),
322            Some(ScalarImpl::Decimal(Decimal::from_str("0.111111").unwrap())),
323            Some(ScalarImpl::Decimal(Decimal::from_str("-0.01").unwrap())),
324        ];
325        let data_type = [
326            DataType::Int32,
327            DataType::Int64,
328            DataType::Decimal,
329            DataType::Decimal,
330            DataType::Decimal,
331            DataType::Decimal,
332        ];
333
334        for i in 0..values.len() {
335            let value = Value::Number(String::from(values[i]));
336            let res = binder.bind_value(&value).unwrap();
337            let ans = Literal::new(data[i].clone(), data_type[i].clone());
338            assert_eq!(res, ans);
339        }
340    }
341
342    #[tokio::test]
343    async fn test_bind_radix() {
344        let mut binder = mock_binder();
345
346        for (input, expected) in [
347            ("0x42e3", ScalarImpl::Int32(0x42e3)),
348            ("-0x40", ScalarImpl::Int32(-0x40)),
349            ("0b1101", ScalarImpl::Int32(0b1101)),
350            ("-0b101", ScalarImpl::Int32(-0b101)),
351            ("0o664", ScalarImpl::Int32(0o664)),
352            ("-0o755", ScalarImpl::Int32(-0o755)),
353            ("2147483647", ScalarImpl::Int32(2147483647)),
354            ("2147483648", ScalarImpl::Int64(2147483648)),
355            ("-2147483648", ScalarImpl::Int32(-2147483648)),
356            ("0x7fffffff", ScalarImpl::Int32(0x7fffffff)),
357            ("0x80000000", ScalarImpl::Int64(0x80000000)),
358            ("-0x80000000", ScalarImpl::Int32(-0x80000000)),
359        ] {
360            let lit = binder.bind_number(input.into()).unwrap();
361            assert_eq!(lit.get_data().as_ref().unwrap(), &expected);
362        }
363    }
364
365    #[tokio::test]
366    async fn test_bind_scientific_number() {
367        use std::str::FromStr;
368
369        let mut binder = mock_binder();
370        let values = [
371            ("1e6"),
372            ("1.25e6"),
373            ("1.25e1"),
374            ("1e-2"),
375            ("1.25e-2"),
376            ("1e15"),
377        ];
378        let data = [
379            Some(ScalarImpl::Decimal(Decimal::from_str("1000000").unwrap())),
380            Some(ScalarImpl::Decimal(Decimal::from_str("1250000").unwrap())),
381            Some(ScalarImpl::Decimal(Decimal::from_str("12.5").unwrap())),
382            Some(ScalarImpl::Decimal(Decimal::from_str("0.01").unwrap())),
383            Some(ScalarImpl::Decimal(Decimal::from_str("0.0125").unwrap())),
384            Some(ScalarImpl::Decimal(
385                Decimal::from_str("1000000000000000").unwrap(),
386            )),
387        ];
388        let data_type = [
389            DataType::Decimal,
390            DataType::Decimal,
391            DataType::Decimal,
392            DataType::Decimal,
393            DataType::Decimal,
394            DataType::Decimal,
395        ];
396
397        for i in 0..values.len() {
398            let res = binder.bind_value(&Number(values[i].to_owned())).unwrap();
399            let ans = Literal::new(data[i].clone(), data_type[i].clone());
400            assert_eq!(res, ans);
401        }
402    }
403
404    #[test]
405    fn test_array_expr() {
406        let expr: ExprImpl = FunctionCall::new_unchecked(
407            ExprType::Array,
408            vec![ExprImpl::literal_int(11)],
409            DataType::Int32.list(),
410        )
411        .into();
412        let expr_pb = expr.to_expr_proto();
413        let expr = build_from_prost(&expr_pb).unwrap();
414        match expr.return_type() {
415            DataType::List(list) => {
416                assert_eq!(list.into_elem(), DataType::Int32);
417            }
418            _ => panic!("unexpected type"),
419        };
420    }
421
422    #[test]
423    fn test_array_index_expr() {
424        let array_expr = FunctionCall::new_unchecked(
425            ExprType::Array,
426            vec![ExprImpl::literal_int(11), ExprImpl::literal_int(22)],
427            DataType::Int32.list(),
428        )
429        .into();
430
431        let expr: ExprImpl = FunctionCall::new_unchecked(
432            ExprType::ArrayAccess,
433            vec![array_expr, ExprImpl::literal_int(1)],
434            DataType::Int32,
435        )
436        .into();
437
438        let expr_pb = expr.to_expr_proto();
439        let expr = build_from_prost(&expr_pb).unwrap();
440        assert_eq!(expr.return_type(), DataType::Int32);
441    }
442
443    #[tokio::test]
444    async fn test_bind_interval() {
445        let mut binder = mock_binder();
446        let values = [
447            "1 hour",
448            "1 h",
449            "1 year",
450            "6 second",
451            "2 minutes",
452            "1 month",
453        ];
454        let data = [
455            Literal::new(
456                Some(ScalarImpl::Interval(Interval::from_minutes(60))),
457                DataType::Interval,
458            ),
459            Literal::new(
460                Some(ScalarImpl::Interval(Interval::from_minutes(60))),
461                DataType::Interval,
462            ),
463            Literal::new(
464                Some(ScalarImpl::Interval(Interval::from_ymd(1, 0, 0))),
465                DataType::Interval,
466            ),
467            Literal::new(
468                Some(ScalarImpl::Interval(Interval::from_millis(6 * 1000))),
469                DataType::Interval,
470            ),
471            Literal::new(
472                Some(ScalarImpl::Interval(Interval::from_minutes(2))),
473                DataType::Interval,
474            ),
475            Literal::new(
476                Some(ScalarImpl::Interval(Interval::from_month(1))),
477                DataType::Interval,
478            ),
479        ];
480
481        for i in 0..values.len() {
482            let value = Value::Interval {
483                value: values[i].to_owned(),
484                leading_field: None,
485                leading_precision: None,
486                last_field: None,
487                fractional_seconds_precision: None,
488            };
489            assert_eq!(binder.bind_value(&value).unwrap(), data[i]);
490        }
491    }
492}
risingwave_frontend/binder/expr/value.rs

risingwave_frontend/binder/expr/
value.rs
