risingwave_frontend/binder/relation/
table_function.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 std::str::FromStr;
16
17use itertools::Itertools;
18use risingwave_common::bail_not_implemented;
19use risingwave_common::catalog::{Field, RW_INTERNAL_TABLE_FUNCTION_NAME, Schema};
20use risingwave_common::types::DataType;
21use risingwave_sqlparser::ast::{Function, FunctionArg, FunctionArgList, ObjectName, TableAlias};
22
23use super::watermark::is_watermark_func;
24use super::{Binder, Relation, Result, WindowTableFunctionKind};
25use crate::binder::bind_context::Clause;
26use crate::error::ErrorCode;
27use crate::expr::{Expr, ExprImpl};
28
29impl Binder {
30    /// Binds a table function AST, which is a function call in a relation position.
31    ///
32    /// Besides [`crate::expr::TableFunction`] expr, it can also be other things like window table
33    /// functions, or scalar functions.
34    ///
35    /// `with_ordinality` is only supported for the `TableFunction` case now.
36    pub(super) fn bind_table_function(
37        &mut self,
38        name: ObjectName,
39        alias: Option<TableAlias>,
40        args: Vec<FunctionArg>,
41        with_ordinality: bool,
42    ) -> Result<Relation> {
43        let func_name = &name.0[0].real_value();
44        // internal/system table functions
45        {
46            if func_name.eq_ignore_ascii_case(RW_INTERNAL_TABLE_FUNCTION_NAME) {
47                if with_ordinality {
48                    bail_not_implemented!(
49                        "WITH ORDINALITY for internal/system table function {}",
50                        func_name
51                    );
52                }
53                return self.bind_internal_table(args, alias);
54            }
55        }
56        // window table functions (tumble/hop)
57        if let Ok(kind) = WindowTableFunctionKind::from_str(func_name) {
58            if with_ordinality {
59                return Err(ErrorCode::InvalidInputSyntax(format!(
60                    "WITH ORDINALITY for window table function {}",
61                    func_name
62                ))
63                .into());
64            }
65            return Ok(Relation::WindowTableFunction(Box::new(
66                self.bind_window_table_function(alias, kind, args)?,
67            )));
68        }
69        // watermark
70        if is_watermark_func(func_name) {
71            if with_ordinality {
72                return Err(ErrorCode::InvalidInputSyntax(
73                    "WITH ORDINALITY for watermark".to_owned(),
74                )
75                .into());
76            }
77            return Ok(Relation::Watermark(Box::new(
78                self.bind_watermark(alias, args)?,
79            )));
80        };
81
82        self.push_context();
83        let mut clause = Some(Clause::From);
84        std::mem::swap(&mut self.context.clause, &mut clause);
85        let func = self.bind_function(Function {
86            scalar_as_agg: false,
87            name,
88            arg_list: FunctionArgList::args_only(args),
89            over: None,
90            filter: None,
91            within_group: None,
92        });
93        self.context.clause = clause;
94        self.pop_context()?;
95        let func = func?;
96
97        if let ExprImpl::TableFunction(func) = &func {
98            if func.args.iter().any(|arg| arg.has_subquery()) {
99                // Same error reports as DuckDB.
100                return Err(ErrorCode::InvalidInputSyntax(
101                    format!("Only table-in-out functions can have subquery parameters. The table function has subquery parameters is {}", func.name()),
102                )
103                    .into());
104            }
105        }
106
107        // bool indicates if the field is hidden
108        let mut columns = if let DataType::Struct(s) = func.return_type() {
109            // If the table function returns a struct, it will be flattened into multiple columns.
110            let schema = Schema::from(&s);
111            schema.fields.into_iter().map(|f| (false, f)).collect_vec()
112        } else {
113            // If there is an table alias (and it doesn't return a struct),
114            // we should use the alias as the table function's
115            // column name. If column aliases are also provided, they
116            // are handled in bind_table_to_context.
117            //
118            // Note: named return value should take precedence over table alias.
119            // But we don't support it yet.
120            // e.g.,
121            // ```sql
122            // > create function foo(ret out int) language sql as 'select 1';
123            // > select t.ret from foo() as t;
124            // ```
125            let col_name = if let Some(alias) = &alias {
126                alias.name.real_value()
127            } else {
128                func_name.clone()
129            };
130            vec![(false, Field::with_name(func.return_type(), col_name))]
131        };
132        if with_ordinality {
133            columns.push((false, Field::with_name(DataType::Int64, "ordinality")));
134        }
135
136        self.bind_table_to_context(columns, func_name.clone(), alias)?;
137
138        Ok(Relation::TableFunction {
139            expr: func,
140            with_ordinality,
141        })
142    }
143}
risingwave_frontend/binder/relation/table_function.rs

risingwave_frontend/binder/relation/
table_function.rs
