Skip to main content

risingwave_frontend/binder/relation/
table_or_source.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 std::collections::BTreeMap;
16use std::sync::Arc;
17
18use itertools::Itertools;
19use risingwave_common::acl::AclMode;
20use risingwave_common::bail_not_implemented;
21use risingwave_common::catalog::{
22    Engine, Field, debug_assert_column_ids_distinct, is_system_schema,
23};
24use risingwave_common::session_config::USER_NAME_WILD_CARD;
25use risingwave_connector::WithPropertiesExt;
26use risingwave_connector::sink::catalog::SinkCatalog;
27use risingwave_connector::sink::iceberg::IcebergMetadataTableType;
28use risingwave_pb::secret::PbSecretRef;
29use risingwave_pb::user::grant_privilege::PbObject;
30use risingwave_sqlparser::ast::{AsOf, ObjectName, Statement, TableAlias};
31use risingwave_sqlparser::parser::Parser;
32use thiserror_ext::AsReport;
33
34use super::BoundShare;
35use crate::binder::relation::BoundShareInput;
36use crate::binder::{BindFor, Binder, Relation};
37use crate::catalog::root_catalog::SchemaPath;
38use crate::catalog::source_catalog::SourceCatalog;
39use crate::catalog::system_catalog::SystemTableCatalog;
40use crate::catalog::table_catalog::TableCatalog;
41use crate::catalog::view_catalog::ViewCatalog;
42use crate::catalog::{
43    CatalogError, CatalogResult, DatabaseId, IndexCatalog, RelationKind, TableId,
44};
45use crate::error::ErrorCode::PermissionDenied;
46use crate::error::{ErrorCode, Result, RwError};
47use crate::handler::privilege::ObjectCheckItem;
48
49#[derive(Debug, Clone)]
50pub struct BoundBaseTable {
51    pub table_id: TableId,
52    pub table_catalog: Arc<TableCatalog>,
53    pub table_indexes: Vec<Arc<IndexCatalog>>,
54    pub as_of: Option<AsOf>,
55}
56
57#[derive(Debug, Clone)]
58pub struct BoundSystemTable {
59    pub table_id: TableId,
60    pub sys_table_catalog: Arc<SystemTableCatalog>,
61}
62
63#[derive(Debug, Clone)]
64pub struct BoundIcebergMetadataTable {
65    pub metadata_type: IcebergMetadataTableType,
66    pub properties: BTreeMap<String, String>,
67    pub secret_refs: BTreeMap<String, PbSecretRef>,
68    pub as_of: Option<AsOf>,
69}
70
71enum IcebergMetadataBaseRelation {
72    Table(Arc<TableCatalog>),
73    Source(SourceCatalog, bool),
74    Sink(Arc<SinkCatalog>),
75}
76
77#[derive(Debug, Clone)]
78pub struct BoundSource {
79    pub catalog: SourceCatalog,
80    pub as_of: Option<AsOf>,
81}
82
83impl BoundSource {
84    pub fn is_shareable_cdc_connector(&self) -> bool {
85        self.catalog.with_properties.is_shareable_cdc_connector()
86    }
87
88    pub fn is_shared(&self) -> bool {
89        self.catalog.info.is_shared()
90    }
91}
92
93impl Binder {
94    pub fn bind_catalog_relation_by_object_name(
95        &mut self,
96        object_name: &ObjectName,
97        bind_creating_relations: bool,
98    ) -> Result<Relation> {
99        let (schema_name, table_name) =
100            Binder::resolve_schema_qualified_name(&self.db_name, object_name)?;
101        self.bind_catalog_relation_by_name(
102            None,
103            schema_name.as_deref(),
104            &table_name,
105            None,
106            None,
107            bind_creating_relations,
108        )
109    }
110
111    /// Binds table or source, or logical view according to what we get from the catalog.
112    pub fn bind_catalog_relation_by_name(
113        &mut self,
114        db_name: Option<&str>,
115        schema_name: Option<&str>,
116        table_name: &str,
117        alias: Option<&TableAlias>,
118        as_of: Option<&AsOf>,
119        bind_creating_relations: bool,
120    ) -> Result<Relation> {
121        // define some helper functions converting catalog to bound relation
122        let resolve_sys_table_relation = |sys_table_catalog: &Arc<SystemTableCatalog>| {
123            let table = BoundSystemTable {
124                table_id: sys_table_catalog.id(),
125                sys_table_catalog: sys_table_catalog.clone(),
126            };
127            (
128                Relation::SystemTable(Box::new(table)),
129                sys_table_catalog
130                    .columns
131                    .iter()
132                    .map(|c| (c.is_hidden, Field::from(&c.column_desc)))
133                    .collect_vec(),
134            )
135        };
136
137        // check db_name if exists first
138        if let Some(db_name) = db_name {
139            let _ = self.catalog.get_database_by_name(db_name)?;
140        }
141
142        // start to bind
143        let (ret, columns) = {
144            match schema_name {
145                Some(schema_name) => {
146                    let db_name = db_name.unwrap_or(&self.db_name).to_owned();
147                    let schema_path = SchemaPath::Name(schema_name);
148                    if is_system_schema(schema_name) {
149                        if let Ok(sys_table_catalog) =
150                            self.catalog
151                                .get_sys_table_by_name(&db_name, schema_name, table_name)
152                        {
153                            resolve_sys_table_relation(sys_table_catalog)
154                        } else if let Ok((view_catalog, _)) =
155                            self.catalog
156                                .get_view_by_name(&db_name, schema_path, table_name)
157                        {
158                            self.resolve_view_relation(&view_catalog.clone())?
159                        } else {
160                            bail_not_implemented!(
161                                issue = 1695,
162                                r###"{}.{} is not supported, please use `SHOW` commands for now.
163`SHOW TABLES`,
164`SHOW MATERIALIZED VIEWS`,
165`DESCRIBE <table>`,
166`SHOW COLUMNS FROM [table]`
167"###,
168                                schema_name,
169                                table_name
170                            );
171                        }
172                    } else if let Some(source_catalog) =
173                        self.temporary_source_manager.get_source(table_name)
174                    // don't care about the database and schema
175                    {
176                        self.resolve_source_relation(&source_catalog.clone(), as_of, true)?
177                    } else if let Ok((table_catalog, schema_name)) = self
178                        .catalog
179                        .get_any_table_by_name(&db_name, schema_path, table_name)
180                        && (bind_creating_relations
181                            || table_catalog.is_internal_table()
182                            || table_catalog.is_created())
183                    {
184                        self.resolve_table_relation(
185                            table_catalog.clone(),
186                            &db_name,
187                            schema_name,
188                            as_of,
189                        )?
190                    } else if let Ok((source_catalog, _)) =
191                        self.catalog
192                            .get_source_by_name(&db_name, schema_path, table_name)
193                    {
194                        self.resolve_source_relation(&source_catalog.clone(), as_of, false)?
195                    } else if let Ok((view_catalog, _)) =
196                        self.catalog
197                            .get_view_by_name(&db_name, schema_path, table_name)
198                    {
199                        self.resolve_view_relation(&view_catalog.clone())?
200                    } else if let Some(table_catalog) =
201                        self.staging_catalog_manager.get_table(table_name)
202                    {
203                        // don't care about the database and schema
204                        self.resolve_table_relation(
205                            table_catalog.clone().into(),
206                            &db_name,
207                            schema_name,
208                            as_of,
209                        )?
210                    } else {
211                        self.resolve_iceberg_metadata_relation(
212                            &db_name,
213                            Some(schema_name),
214                            table_name,
215                            as_of,
216                        )?
217                    }
218                }
219                None => (|| {
220                    // If schema is not specified, db must be unspecified.
221                    // So we should always use current database here.
222                    assert!(db_name.is_none());
223                    let db_name = self.db_name.clone();
224                    let user_name = self.auth_context.user_name.clone();
225
226                    for path in self.search_path.path() {
227                        if is_system_schema(path)
228                            && let Ok(sys_table_catalog) = self
229                                .catalog
230                                .get_sys_table_by_name(&db_name, path, table_name)
231                        {
232                            return Ok(resolve_sys_table_relation(sys_table_catalog));
233                        } else {
234                            let schema_name = if path == USER_NAME_WILD_CARD {
235                                &user_name
236                            } else {
237                                &path.clone()
238                            };
239
240                            if let Ok(schema) =
241                                self.catalog.get_schema_by_name(&db_name, schema_name)
242                            {
243                                if let Some(source_catalog) =
244                                    self.temporary_source_manager.get_source(table_name)
245                                // don't care about the database and schema
246                                {
247                                    return self.resolve_source_relation(
248                                        &source_catalog.clone(),
249                                        as_of,
250                                        true,
251                                    );
252                                } else if let Some(table_catalog) =
253                                    schema.get_any_table_by_name(table_name)
254                                    && (bind_creating_relations
255                                        || table_catalog.is_internal_table()
256                                        || table_catalog.is_created())
257                                {
258                                    return self.resolve_table_relation(
259                                        table_catalog.clone(),
260                                        &db_name,
261                                        schema_name,
262                                        as_of,
263                                    );
264                                } else if let Some(source_catalog) =
265                                    schema.get_source_by_name(table_name)
266                                {
267                                    return self.resolve_source_relation(
268                                        &source_catalog.clone(),
269                                        as_of,
270                                        false,
271                                    );
272                                } else if let Some(view_catalog) =
273                                    schema.get_view_by_name(table_name)
274                                {
275                                    return self.resolve_view_relation(&view_catalog.clone());
276                                } else if let Some(table_catalog) =
277                                    self.staging_catalog_manager.get_table(table_name)
278                                {
279                                    // don't care about the database and schema
280                                    return self.resolve_table_relation(
281                                        table_catalog.clone().into(),
282                                        &db_name,
283                                        schema_name,
284                                        as_of,
285                                    );
286                                }
287                            }
288                        }
289                    }
290
291                    self.resolve_iceberg_metadata_relation(&db_name, None, table_name, as_of)
292                })()?,
293            }
294        };
295
296        self.bind_table_to_context(
297            columns,
298            table_name.to_owned(),
299            schema_name.map(|s| s.to_owned()),
300            alias,
301        )?;
302        Ok(ret)
303    }
304
305    /// Returns the error for a name that doesn't resolve to anything queryable. Sinks and
306    /// subscriptions share the namespace of relations but can't be queried. Only the current
307    /// database is inspected, so the error doesn't reveal objects in other databases.
308    fn relation_not_found_error(
309        &self,
310        db_name: &str,
311        schema_name: Option<&str>,
312        relation_name: &str,
313        not_found: CatalogError,
314    ) -> RwError {
315        if db_name == self.db_name
316            && let Some(kind @ (RelationKind::Sink | RelationKind::Subscription)) = self
317                .catalog
318                .relation_kind(db_name, self.bind_schema_path(schema_name), relation_name)
319        {
320            return kind.cannot_query_error(relation_name).into();
321        }
322        not_found.into()
323    }
324
325    fn resolve_iceberg_metadata_relation(
326        &mut self,
327        db_name: &str,
328        schema_name: Option<&str>,
329        relation_name: &str,
330        as_of: Option<&AsOf>,
331    ) -> Result<(Relation, Vec<(bool, Field)>)> {
332        let metadata_relation = relation_name
333            .rsplit_once('$')
334            .filter(|(base_name, _)| !base_name.is_empty())
335            .and_then(|(base_name, suffix)| {
336                Some((base_name, IcebergMetadataTableType::from_suffix(suffix)?))
337            });
338        let Some((base_name, metadata_type)) = metadata_relation else {
339            return Err(self.relation_not_found_error(
340                db_name,
341                schema_name,
342                relation_name,
343                CatalogError::not_found("table or source", relation_name),
344            ));
345        };
346
347        if metadata_type == IcebergMetadataTableType::Snapshots && as_of.is_some() {
348            return Err(ErrorCode::BindError(
349                "time travel is only supported for Iceberg manifests and files metadata relations"
350                    .to_owned(),
351            )
352            .into());
353        }
354        if matches!(
355            as_of,
356            Some(AsOf::ProcessTime | AsOf::ProcessTimeBroadcast | AsOf::ProcessTimeWithInterval(_))
357        ) {
358            bail_not_implemented!(
359                "As Of ProcessTime() is not supported for Iceberg metadata relations."
360            );
361        }
362
363        let (base_relation, resolved_schema_name) = if let Some(source) =
364            self.temporary_source_manager.get_source(base_name)
365        {
366            (
367                IcebergMetadataBaseRelation::Source(source.clone(), true),
368                None,
369            )
370        } else {
371            let schema_path = self.bind_schema_path(schema_name);
372            let Some((base_relation, resolved_schema_name)) =
373                schema_path.try_find(|schema_name| -> CatalogResult<_> {
374                    let schema = self.catalog.get_schema_by_name(db_name, schema_name)?;
375                    Ok(schema
376                        .get_created_table_by_name(base_name)
377                        .map(|table| IcebergMetadataBaseRelation::Table(table.clone()))
378                        .or_else(|| {
379                            schema.get_source_by_name(base_name).map(|source| {
380                                IcebergMetadataBaseRelation::Source(source.as_ref().clone(), false)
381                            })
382                        })
383                        .or_else(|| {
384                            schema
385                                .get_created_sink_by_name(base_name)
386                                .map(|sink| IcebergMetadataBaseRelation::Sink(sink.clone()))
387                        }))
388                })?
389            else {
390                return Err(self.relation_not_found_error(
391                    db_name,
392                    schema_name,
393                    relation_name,
394                    CatalogError::not_found("Iceberg table, source, or sink", base_name),
395                ));
396            };
397            (base_relation, Some(resolved_schema_name.to_owned()))
398        };
399
400        let (properties, secret_refs) = match base_relation {
401            IcebergMetadataBaseRelation::Table(table) => {
402                self.check_privilege(
403                    ObjectCheckItem::new(
404                        table.owner,
405                        AclMode::Select,
406                        table.name.clone(),
407                        table.id(),
408                    ),
409                    table.database_id,
410                )?;
411                if table.engine() != Engine::Iceberg {
412                    return Err(ErrorCode::BindError(format!(
413                        "metadata relation \"{relation_name}\" requires an Iceberg engine table, source, or sink, but table \"{base_name}\" uses {:?}",
414                        table.engine()
415                    ))
416                    .into());
417                }
418                self.included_relations.insert(table.id().as_object_id());
419
420                let sink_name = table.iceberg_sink_name().ok_or_else(|| {
421                    ErrorCode::CatalogError(
422                        format!("no Iceberg sink found for table \"{base_name}\"").into(),
423                    )
424                })?;
425                let sink = self
426                    .catalog
427                    .get_created_sink_by_name(
428                        db_name,
429                        SchemaPath::Name(
430                            resolved_schema_name
431                                .as_deref()
432                                .expect("catalog tables always have a schema"),
433                        ),
434                        &sink_name,
435                    )
436                    .map_err(|_| {
437                        ErrorCode::CatalogError(
438                            format!(
439                                "Iceberg sink \"{sink_name}\" not found for table \"{base_name}\""
440                            )
441                            .into(),
442                        )
443                    })?
444                    .0
445                    .clone();
446                (sink.properties.clone(), sink.secret_refs.clone())
447            }
448            IcebergMetadataBaseRelation::Source(source, is_temporary) => {
449                if !is_temporary {
450                    self.check_privilege(
451                        ObjectCheckItem::new(
452                            source.owner,
453                            AclMode::Select,
454                            source.name.clone(),
455                            source.id,
456                        ),
457                        source.database_id,
458                    )?;
459                }
460                if !source.is_iceberg_connector() {
461                    return Err(ErrorCode::BindError(format!(
462                        "metadata relation \"{relation_name}\" requires an Iceberg source, but source \"{base_name}\" uses a different connector"
463                    ))
464                    .into());
465                }
466                self.included_relations.insert(source.id.as_object_id());
467                source.with_properties.into_parts()
468            }
469            IcebergMetadataBaseRelation::Sink(sink) => {
470                self.check_privilege(
471                    ObjectCheckItem::new(sink.owner, AclMode::Select, sink.name.clone(), sink.id),
472                    sink.database_id,
473                )?;
474                if !sink.properties.is_iceberg_connector() {
475                    return Err(ErrorCode::BindError(format!(
476                        "metadata relation \"{relation_name}\" requires an Iceberg sink, but sink \"{base_name}\" uses a different connector"
477                    ))
478                    .into());
479                }
480                self.included_relations.insert(sink.id.as_object_id());
481                (sink.properties.clone(), sink.secret_refs.clone())
482            }
483        };
484
485        let columns = metadata_type
486            .schema()
487            .fields
488            .into_iter()
489            .map(|field| (false, field))
490            .collect();
491        Ok((
492            Relation::IcebergMetadataTable(Box::new(BoundIcebergMetadataTable {
493                metadata_type,
494                properties,
495                secret_refs,
496                as_of: as_of.cloned(),
497            })),
498            columns,
499        ))
500    }
501
502    pub(crate) fn check_privilege(
503        &self,
504        item: ObjectCheckItem,
505        database_id: DatabaseId,
506    ) -> Result<()> {
507        // security invoker is disabled for view, ignore privilege check.
508        if self.context.disable_security_invoker {
509            return Ok(());
510        }
511
512        match self.bind_for {
513            BindFor::Stream | BindFor::Batch => {
514                // reject sources for cross-db access
515                if matches!(self.bind_for, BindFor::Stream)
516                    && self.database_id != database_id
517                    && matches!(item.object, PbObject::SourceId(_))
518                {
519                    return Err(PermissionDenied(format!(
520                        "SOURCE \"{}\" is not allowed for cross-db access",
521                        item.name
522                    ))
523                    .into());
524                }
525                if let Some(user) = self.user.get_user_by_name(&self.auth_context.user_name) {
526                    if user.is_super || user.id == item.owner {
527                        return Ok(());
528                    }
529                    if !user.has_privilege(item.object, item.mode) {
530                        return Err(PermissionDenied(item.error_message()).into());
531                    }
532
533                    // check CONNECT privilege for cross-db access
534                    if self.database_id != database_id
535                        && !user.has_privilege(database_id, AclMode::Connect)
536                    {
537                        let db_name = self.catalog.get_database_by_id(database_id)?.name.clone();
538
539                        return Err(PermissionDenied(format!(
540                            "permission denied for database \"{db_name}\""
541                        ))
542                        .into());
543                    }
544                } else {
545                    return Err(PermissionDenied("Session user is invalid".to_owned()).into());
546                }
547            }
548            BindFor::Ddl | BindFor::System => {
549                // do nothing.
550            }
551        }
552        Ok(())
553    }
554
555    fn resolve_table_relation(
556        &mut self,
557        table_catalog: Arc<TableCatalog>,
558        db_name: &str,
559        schema_name: &str,
560        as_of: Option<&AsOf>,
561    ) -> Result<(Relation, Vec<(bool, Field)>)> {
562        let table_id = table_catalog.id();
563        let columns = table_catalog
564            .columns
565            .iter()
566            .map(|c| (c.is_hidden, Field::from(&c.column_desc)))
567            .collect_vec();
568        self.check_privilege(
569            ObjectCheckItem::new(
570                table_catalog.owner,
571                AclMode::Select,
572                table_catalog.name.clone(),
573                table_id,
574            ),
575            table_catalog.database_id,
576        )?;
577        self.included_relations.insert(table_id.as_object_id());
578
579        let table_indexes = self.resolve_table_indexes(db_name, schema_name, table_id)?;
580
581        let table = BoundBaseTable {
582            table_id,
583            table_catalog,
584            table_indexes,
585            as_of: as_of.cloned(),
586        };
587
588        Ok::<_, RwError>((Relation::BaseTable(Box::new(table)), columns))
589    }
590
591    fn resolve_source_relation(
592        &mut self,
593        source_catalog: &SourceCatalog,
594        as_of: Option<&AsOf>,
595        is_temporary: bool,
596    ) -> Result<(Relation, Vec<(bool, Field)>)> {
597        source_catalog.validate_iceberg_update_source()?;
598        debug_assert_column_ids_distinct(&source_catalog.columns);
599        if !is_temporary {
600            self.check_privilege(
601                ObjectCheckItem::new(
602                    source_catalog.owner,
603                    AclMode::Select,
604                    source_catalog.name.clone(),
605                    source_catalog.id,
606                ),
607                source_catalog.database_id,
608            )?;
609        }
610        self.included_relations
611            .insert(source_catalog.id.as_object_id());
612        Ok((
613            Relation::Source(Box::new(BoundSource {
614                catalog: source_catalog.clone(),
615                as_of: as_of.cloned(),
616            })),
617            source_catalog
618                .columns
619                .iter()
620                .map(|c| (c.is_hidden, Field::from(&c.column_desc)))
621                .collect_vec(),
622        ))
623    }
624
625    fn resolve_view_relation(
626        &mut self,
627        view_catalog: &ViewCatalog,
628    ) -> Result<(Relation, Vec<(bool, Field)>)> {
629        if !view_catalog.is_system_view() {
630            self.check_privilege(
631                ObjectCheckItem::new(
632                    view_catalog.owner,
633                    AclMode::Select,
634                    view_catalog.name.clone(),
635                    view_catalog.id,
636                ),
637                view_catalog.database_id,
638            )?;
639        }
640
641        // The error leaves out the SQL and the parser's message, which quotes it, as they can have
642        // secrets.
643        let ast = Parser::parse_sql(&view_catalog.sql).map_err(|_| {
644            ErrorCode::BindError(format!(
645                "failed to parse the stored definition of view {}",
646                view_catalog.name
647            ))
648        })?;
649        let Statement::Query(query) = Itertools::exactly_one(ast.into_iter())
650            .expect("a view should contain only one statement")
651        else {
652            unreachable!("a view should contain a query statement");
653        };
654        let query = self.bind_query_for_view(&query).map_err(|e| {
655            ErrorCode::BindError(format!(
656                "failed to bind view {}, sql: {}\nerror: {}",
657                view_catalog.name,
658                view_catalog.sql,
659                e.as_report()
660            ))
661        })?;
662
663        let columns = view_catalog.columns.clone();
664
665        if !itertools::equal(
666            query.schema().fields().iter().map(|f| &f.data_type),
667            view_catalog.columns.iter().map(|f| &f.data_type),
668        ) {
669            return Err(ErrorCode::BindError(format!(
670                "failed to bind view {}. The SQL's schema is different from catalog's schema sql: {}, bound schema: {:?}, catalog schema: {:?}",
671                view_catalog.name, view_catalog.sql, query.schema(), columns
672            )).into());
673        }
674
675        let share_id = match self.shared_views.get(&view_catalog.id) {
676            Some(share_id) => *share_id,
677            None => {
678                let share_id = self.next_share_id();
679                self.shared_views.insert(view_catalog.id, share_id);
680                self.included_relations
681                    .insert(view_catalog.id.as_object_id());
682                share_id
683            }
684        };
685        Ok((
686            Relation::Share(Box::new(BoundShare {
687                share_id,
688                input: BoundShareInput::Query(query),
689            })),
690            columns.iter().map(|c| (false, c.clone())).collect_vec(),
691        ))
692    }
693
694    fn resolve_table_indexes(
695        &self,
696        db_name: &str,
697        schema_name: &str,
698        table_id: TableId,
699    ) -> Result<Vec<Arc<IndexCatalog>>> {
700        let schema = self.catalog.get_schema_by_name(db_name, schema_name)?;
701        assert!(
702            schema.get_table_by_id(table_id).is_some() || table_id.is_placeholder(),
703            "table {table_id} not found in {db_name}.{schema_name}"
704        );
705
706        Ok(schema.get_created_indexes_by_table_id(table_id))
707    }
708
709    pub(crate) fn bind_table(
710        &mut self,
711        schema_name: Option<&str>,
712        table_name: &str,
713    ) -> Result<BoundBaseTable> {
714        let db_name = &self.db_name;
715        let schema_path = self.bind_schema_path(schema_name);
716        let (table_catalog, schema_name) =
717            self.catalog
718                .get_created_table_by_name(db_name, schema_path, table_name)?;
719        let table_catalog = table_catalog.clone();
720
721        let table_id = table_catalog.id();
722        let table_indexes = self.resolve_table_indexes(db_name, schema_name, table_id)?;
723
724        let columns = table_catalog.columns.clone();
725
726        self.bind_table_to_context(
727            columns
728                .iter()
729                .map(|c| (c.is_hidden, (&c.column_desc).into())),
730            table_name.to_owned(),
731            Some(schema_name.to_owned()),
732            None,
733        )?;
734
735        Ok(BoundBaseTable {
736            table_id,
737            table_catalog,
738            table_indexes,
739            as_of: None,
740        })
741    }
742
743    /// Binds the target table of `INSERT`, `UPDATE` or `DELETE`.
744    pub(crate) fn bind_table_for_dml(
745        &mut self,
746        schema_name: Option<&str>,
747        table_name: &str,
748        is_insert: bool,
749    ) -> Result<BoundBaseTable> {
750        let table = self.bind_table(schema_name, table_name).map_err(|e| {
751            let schema_path = self.bind_schema_path(schema_name);
752            match self
753                .catalog
754                .relation_kind(&self.db_name, schema_path, table_name)
755            {
756                Some(kind) if kind != RelationKind::Table => {
757                    kind.cannot_change_error(table_name).into()
758                }
759                _ => e,
760            }
761        })?;
762        Self::check_for_dml(&table.table_catalog, is_insert)?;
763        Ok(table)
764    }
765
766    fn check_for_dml(table: &TableCatalog, is_insert: bool) -> Result<()> {
767        let kind = RelationKind::from(table.table_type());
768        if kind != RelationKind::Table {
769            return Err(kind.cannot_change_error(&table.name).into());
770        }
771
772        if table.append_only && !is_insert {
773            return Err(ErrorCode::BindError(
774                "append-only table does not support update or delete".to_owned(),
775            )
776            .into());
777        }
778
779        Ok(())
780    }
781}
782
783#[cfg(test)]
784mod tests {
785    use risingwave_common::catalog::{DEFAULT_SUPER_USER_ID, SYS_CATALOG_START_ID};
786
787    use super::*;
788    use crate::binder::test_utils::mock_binder;
789
790    #[tokio::test]
791    async fn test_view_with_unparsable_sql() {
792        let view = ViewCatalog {
793            // A system view skips the privilege check.
794            id: (SYS_CATALOG_START_ID as u32).into(),
795            name: "v".to_owned(),
796            schema_id: 0.into(),
797            database_id: 0.into(),
798            owner: DEFAULT_SUPER_USER_ID,
799            properties: Default::default(),
800            sql: "SELECT 'secret' FROM".to_owned(),
801            columns: vec![],
802            created_at_epoch: None,
803            created_at_cluster_version: None,
804        };
805        let error = mock_binder()
806            .resolve_view_relation(&view)
807            .unwrap_err()
808            .to_report_string();
809        assert!(error.contains("view v"), "{error}");
810        assert!(!error.contains("secret"), "{error}");
811    }
812}