risingwave_frontend/binder/
struct_field.rs

1// Copyright 2025 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 itertools::Itertools;
16use risingwave_common::types::{DataType, Scalar};
17use risingwave_sqlparser::ast::{Expr, Ident};
18
19use crate::binder::Binder;
20use crate::error::{ErrorCode, Result};
21use crate::expr::{Expr as RwExpr, ExprImpl, ExprType, FunctionCall, Literal};
22
23impl Binder {
24    /// Extracts and binds struct column from `expr`.
25    /// Returns the bound column and the remaining fields.
26    ///
27    /// Specifically,
28    /// - `(table).struct_col.fields` -> `(bound_struct_col, fields)`
29    /// - Otherwise, `expr` corresponds to a column. `(expr).fields` -> `(bound_expr, fields)`
30    fn extract_struct_column(
31        &mut self,
32        expr: Expr,
33        field_idents: Vec<Ident>,
34    ) -> Result<(ExprImpl, Vec<Ident>)> {
35        let d = self.bind_expr(expr)?;
36        Ok((d, field_idents))
37    }
38
39    /// Binds wildcard field column, e.g. `(table.v1).*` or `(table).v1.*`.
40    ///
41    /// Returns a vector of `Field(expr, int)` expressions and aliases.
42    pub fn bind_wildcard_field_column(
43        &mut self,
44        expr: Expr,
45        prefix: Vec<Ident>,
46    ) -> Result<(Vec<ExprImpl>, Vec<Option<String>>)> {
47        let (expr, idents) = self.extract_struct_column(expr, prefix)?;
48        let fields = Self::bind_field("".to_owned(), expr, &idents, true)?;
49        let (exprs, names) = fields.into_iter().map(|(e, s)| (e, Some(s))).unzip();
50        Ok((exprs, names))
51    }
52
53    /// Binds single field column, e.g. `(table.v1).v2` or `(table).v1.v2`.
54    ///
55    /// Returns a `Field(expr, int)` expression.
56    pub fn bind_single_field_column(&mut self, expr: Expr, idents: &[Ident]) -> Result<ExprImpl> {
57        let (expr, idents) = self.extract_struct_column(expr, idents.to_vec())?;
58        let exprs = Self::bind_field("".to_owned(), expr, &idents, false)?;
59        Ok(exprs[0].clone().0)
60    }
61
62    /// Bind field in recursive way. It could return a couple Field expressions
63    /// if it ends with a wildcard.
64    fn bind_field(
65        field_name: String,
66        expr: ExprImpl,
67        idents: &[Ident],
68        wildcard: bool,
69    ) -> Result<Vec<(ExprImpl, String)>> {
70        match idents.first() {
71            Some(ident) => {
72                let field_name = ident.real_value();
73                let (field_type, field_index) = find_field(expr.return_type(), ident.real_value())?;
74                let expr = FunctionCall::new_unchecked(
75                    ExprType::Field,
76                    vec![
77                        expr,
78                        Literal::new(
79                            Some((field_index as i32).to_scalar_value()),
80                            DataType::Int32,
81                        )
82                        .into(),
83                    ],
84                    field_type,
85                )
86                .into();
87                Self::bind_field(field_name, expr, &idents[1..], wildcard)
88            }
89            None => {
90                if wildcard {
91                    Self::bind_wildcard_field(expr)
92                } else {
93                    Ok(vec![(expr, field_name)])
94                }
95            }
96        }
97    }
98
99    /// Will fail if it's an atomic value.
100    /// Rewrite (expr:Struct).* to [Field(expr, 0), Field(expr, 1), ... Field(expr, n)].
101    fn bind_wildcard_field(expr: ExprImpl) -> Result<Vec<(ExprImpl, String)>> {
102        let input = expr.return_type();
103        if let DataType::Struct(t) = input {
104            Ok(t.iter()
105                .enumerate()
106                .map(|(i, (name, ty))| {
107                    (
108                        FunctionCall::new_unchecked(
109                            ExprType::Field,
110                            vec![
111                                expr.clone(),
112                                Literal::new(Some((i as i32).to_scalar_value()), DataType::Int32)
113                                    .into(),
114                            ],
115                            ty.clone(),
116                        )
117                        .into(),
118                        name.to_owned(),
119                    )
120                })
121                .collect_vec())
122        } else {
123            Err(ErrorCode::BindError(format!("type \"{}\" is not composite", input)).into())
124        }
125    }
126}
127
128fn find_field(input: DataType, field_name: String) -> Result<(DataType, usize)> {
129    if let DataType::Struct(t) = input {
130        if let Some((pos, (_, ty))) = t.iter().find_position(|(name, _)| name == &field_name) {
131            Ok((ty.clone(), pos))
132        } else {
133            Err(ErrorCode::BindError(format!(
134                "column \"{}\" not found in struct type",
135                field_name
136            ))
137            .into())
138        }
139    } else {
140        Err(ErrorCode::BindError(format!(
141            "column notation .{} applied to type {}, which is not a composite type",
142            field_name, input
143        ))
144        .into())
145    }
146}
risingwave_frontend/binder/struct_field.rs

risingwave_frontend/binder/
struct_field.rs
