1use 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 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 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 if let Some(db_name) = db_name {
139 let _ = self.catalog.get_database_by_name(db_name)?;
140 }
141
142 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 {
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 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 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 {
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 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 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 if self.context.disable_security_invoker {
509 return Ok(());
510 }
511
512 match self.bind_for {
513 BindFor::Stream | BindFor::Batch => {
514 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 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 }
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 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 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 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}