1pub mod columns;
10pub mod coverage;
11mod enforcement;
12
13use crate::catalog::roles::RoleReference;
14use std::collections::{BTreeMap, BTreeSet};
15
16use crate::plan::{QueryBlockPlan, QueryPlan, RelationalPlan, SourcePlan};
17use crate::SQLError;
18use crate::ScalarExpr;
19
20pub mod context;
21use context::PrivilegeScope as CteScope;
22use enforcement::ensure_required_select;
23
24#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
25struct BaseColumn {
26 table: String,
27 column: String,
28}
29
30#[derive(Clone, Debug)]
31struct OutputColumn {
32 name: String,
33 sources: BTreeSet<BaseColumn>,
34}
35
36#[derive(Clone, Default)]
37struct SourceLineage {
38 output: Vec<OutputColumn>,
39 qualifiers: BTreeMap<String, Vec<OutputColumn>>,
40 system_qualifiers: BTreeMap<String, BTreeSet<String>>,
41 tables: BTreeMap<String, BTreeSet<String>>,
42}
43
44impl SourceLineage {
45 fn has_unqualified(&self, column: &str) -> bool {
46 self.output.iter().any(|output| output.name == column)
47 }
48
49 fn has_qualifier(&self, qualifier: &str) -> bool {
50 self.qualifiers.contains_key(qualifier) || self.system_qualifiers.contains_key(qualifier)
51 }
52
53 fn require_unqualified(&self, column: &str, required: &mut BTreeSet<BaseColumn>) {
54 for output in self.output.iter().filter(|output| output.name == column) {
55 required.extend(output.sources.iter().cloned());
56 }
57 }
58
59 fn require_qualified(
60 &self,
61 qualifier: &str,
62 column: &str,
63 required: &mut BTreeSet<BaseColumn>,
64 ) {
65 if let Some(columns) = self.qualifiers.get(qualifier) {
66 for output in columns.iter().filter(|output| output.name == column) {
67 required.extend(output.sources.iter().cloned());
68 }
69 }
70 }
71
72 fn require_all(&self, required: &mut BTreeSet<BaseColumn>) {
73 for output in &self.output {
74 required.extend(output.sources.iter().cloned());
75 }
76 }
77
78 fn require_qualified_all(&self, qualifier: &str, required: &mut BTreeSet<BaseColumn>) {
79 if let Some(columns) = self.qualifiers.get(qualifier) {
80 for output in columns {
81 required.extend(output.sources.iter().cloned());
82 }
83 }
84 }
85
86 fn require_unqualified_system(&self, column: &str, required: &mut BTreeSet<BaseColumn>) {
87 for table in self.system_qualifiers.values().flatten() {
88 required.insert(BaseColumn {
89 table: table.clone(),
90 column: column.to_string(),
91 });
92 }
93 }
94
95 fn require_qualified_system(
96 &self,
97 qualifier: &str,
98 column: &str,
99 required: &mut BTreeSet<BaseColumn>,
100 ) {
101 if let Some(tables) = self.system_qualifiers.get(qualifier) {
102 required.extend(tables.iter().cloned().map(|table| BaseColumn {
103 table,
104 column: column.to_string(),
105 }));
106 }
107 }
108
109 fn include_tables(&mut self, other: &Self) {
110 for (table, columns) in &other.tables {
111 self.tables
112 .entry(table.clone())
113 .or_default()
114 .extend(columns.iter().cloned());
115 }
116 }
117}
118
119fn opaque_lineage(columns: Vec<String>, qualifier: Option<String>) -> SourceLineage {
120 let output = columns
121 .into_iter()
122 .map(|name| OutputColumn {
123 name,
124 sources: BTreeSet::new(),
125 })
126 .collect::<Vec<_>>();
127 let qualifiers = qualifier.map_or_else(BTreeMap::new, |qualifier| {
128 BTreeMap::from([(qualifier, output.clone())])
129 });
130 SourceLineage {
131 output,
132 qualifiers,
133 system_qualifiers: BTreeMap::new(),
134 tables: BTreeMap::new(),
135 }
136}
137
138fn is_system_column(column: &str) -> bool {
139 matches!(
140 column,
141 "ctid" | "xmin" | "cmin" | "xmax" | "cmax" | "tableoid"
142 )
143}
144
145fn rename_output_columns(output: &mut [OutputColumn], aliases: &[String]) {
146 for (column, alias) in output.iter_mut().zip(aliases) {
147 column.name.clone_from(alias);
148 }
149}
150
151fn table_lineage(
152 name: &str,
153 qualifier: &str,
154 alias: Option<&str>,
155 column_aliases: &[String],
156 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
157) -> Result<SourceLineage, SQLError> {
158 if ctes.is_visible_cte(name) {
159 let columns = ctes
160 .materialized_for_scan(name)
161 .or_else(|| {
162 ctes.deferred_reference(name)
163 .and_then(|cte| cte.body.query())
164 .and_then(crate::semantics::projection::query_plan_output_columns)
165 })
166 .unwrap_or_default();
167 let mut output = opaque_lineage(columns, Some(alias.unwrap_or(qualifier).to_string()));
168 rename_output_columns(&mut output.output, column_aliases);
169 for columns in output.qualifiers.values_mut() {
170 rename_output_columns(columns, column_aliases);
171 }
172 return Ok(output);
173 }
174 let catalog = ctes.catalog;
175 let resolution = ctes.resolution.clone();
176 let Some(relation) = catalog.relation(&resolution, name)? else {
177 return Ok(SourceLineage::default());
178 };
179 let canonical = relation.canonical;
180 let columns = relation.columns;
181 let system_columns = relation.kind.has_system_columns();
182 let visible_qualifier = alias.unwrap_or(qualifier).to_string();
183 let mut output = columns
184 .iter()
185 .map(|column| OutputColumn {
186 name: column.clone(),
187 sources: BTreeSet::from([BaseColumn {
188 table: canonical.clone(),
189 column: column.clone(),
190 }]),
191 })
192 .collect::<Vec<_>>();
193 rename_output_columns(&mut output, column_aliases);
194 Ok(SourceLineage {
195 output: output.clone(),
196 qualifiers: BTreeMap::from([(visible_qualifier, output)]),
197 system_qualifiers: if system_columns {
198 BTreeMap::from([(
199 alias.unwrap_or(qualifier).to_string(),
200 BTreeSet::from([canonical.clone()]),
201 )])
202 } else {
203 BTreeMap::new()
204 },
205 tables: BTreeMap::from([(canonical, columns.into_iter().collect())]),
206 })
207}
208
209fn join_lineage(
210 left: SourceLineage,
211 right: SourceLineage,
212 using: Option<&crate::ast::JoinUsing>,
213 natural: bool,
214 alias: Option<&str>,
215 column_aliases: &[String],
216) -> SourceLineage {
217 let using_columns = using.map_or_else(
218 || {
219 if natural {
220 left.output
221 .iter()
222 .filter(|left| right.output.iter().any(|right| right.name == left.name))
223 .map(|column| column.name.clone())
224 .collect::<Vec<_>>()
225 } else {
226 Vec::new()
227 }
228 },
229 |using| using.columns.clone(),
230 );
231 let using_set = using_columns.iter().collect::<BTreeSet<_>>();
232 let mut output = Vec::new();
233 for column in &using_columns {
234 let mut sources = BTreeSet::new();
235 for candidate in left
236 .output
237 .iter()
238 .chain(&right.output)
239 .filter(|candidate| candidate.name == *column)
240 {
241 sources.extend(candidate.sources.iter().cloned());
242 }
243 output.push(OutputColumn {
244 name: column.clone(),
245 sources,
246 });
247 }
248 output.extend(
249 left.output
250 .iter()
251 .chain(&right.output)
252 .filter(|column| !using_set.contains(&column.name))
253 .cloned(),
254 );
255 let mut tables = left.tables.clone();
256 for (table, columns) in &right.tables {
257 tables
258 .entry(table.clone())
259 .or_default()
260 .extend(columns.iter().cloned());
261 }
262 let (qualifiers, system_qualifiers) = if let Some(alias) = alias {
263 rename_output_columns(&mut output, column_aliases);
264 (
265 BTreeMap::from([(alias.to_string(), output.clone())]),
266 BTreeMap::new(),
267 )
268 } else {
269 let mut qualifiers = left.qualifiers;
270 qualifiers.extend(right.qualifiers);
271 let mut system_qualifiers = left.system_qualifiers;
272 system_qualifiers.extend(right.system_qualifiers);
273 (qualifiers, system_qualifiers)
274 };
275 SourceLineage {
276 output,
277 qualifiers,
278 system_qualifiers,
279 tables,
280 }
281}
282
283fn collect_expression_columns(
284 expression: &ScalarExpr,
285 scopes: &[&SourceLineage],
286 direct_star: bool,
287 required: &mut BTreeSet<BaseColumn>,
288) -> BTreeSet<usize> {
289 if direct_star {
290 match expression {
291 ScalarExpr::Star => {
292 if let Some(scope) = scopes.iter().find(|scope| !scope.output.is_empty()) {
293 scope.require_all(required);
294 }
295 return BTreeSet::new();
296 }
297 ScalarExpr::QualifiedStar(qualifier) => {
298 if let Some(scope) = scopes.iter().find(|scope| scope.has_qualifier(qualifier)) {
299 scope.require_qualified_all(qualifier, required);
300 }
301 return BTreeSet::new();
302 }
303 _ => {}
304 }
305 }
306 let mut subquery_ids = BTreeSet::new();
307 expression.visit(&mut |node| match node {
308 ScalarExpr::Column(column) => {
309 if let Some(scope) = scopes.iter().find(|scope| scope.has_unqualified(column)) {
310 scope.require_unqualified(column, required);
311 } else if is_system_column(column) {
312 if let Some(scope) = scopes
313 .iter()
314 .find(|scope| !scope.system_qualifiers.is_empty())
315 {
316 scope.require_unqualified_system(column, required);
317 }
318 }
319 }
320 ScalarExpr::QualifiedColumn {
321 qualifier, column, ..
322 } => {
323 if let Some(scope) = scopes.iter().find(|scope| scope.has_qualifier(qualifier)) {
324 scope.require_qualified(qualifier, column, required);
325 if is_system_column(column) {
326 scope.require_qualified_system(qualifier, column, required);
327 }
328 }
329 }
330 ScalarExpr::QualifiedStar(qualifier) => {
331 if let Some(scope) = scopes.iter().find(|scope| scope.has_qualifier(qualifier)) {
332 scope.require_qualified_all(qualifier, required);
333 }
334 }
335 ScalarExpr::ScalarSubquery(subquery)
336 | ScalarExpr::Exists { subquery, .. }
337 | ScalarExpr::InSubquery { subquery, .. } => {
338 subquery_ids.insert(*subquery);
339 }
340 _ => {}
341 });
342 subquery_ids
343}
344
345fn collect_expression_and_subqueries(
346 expression: &ScalarExpr,
347 scopes: &[&SourceLineage],
348 direct_star: bool,
349 subqueries: &[QueryPlan],
350 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
351 universe: &mut SourceLineage,
352 required: &mut BTreeSet<BaseColumn>,
353) -> Result<(), SQLError> {
354 for subquery in collect_expression_columns(expression, scopes, direct_star, required) {
355 let plan = subqueries.get(subquery).ok_or_else(|| {
356 SQLError::Internal(format!(
357 "column privilege analysis cannot resolve scalar subquery slot {subquery}"
358 ))
359 })?;
360 analyze_query_plan(plan, ctes, scopes, universe, required)?;
361 }
362 Ok(())
363}
364
365fn values_lineage(
366 rows: &[Vec<ScalarExpr>],
367 alias: Option<&str>,
368 column_aliases: &[String],
369) -> SourceLineage {
370 let columns = if column_aliases.is_empty() {
371 (1..=rows.first().map_or(0, Vec::len))
372 .map(|index| format!("column{index}"))
373 .collect()
374 } else {
375 column_aliases.to_vec()
376 };
377 opaque_lineage(columns, alias.map(str::to_string))
378}
379
380fn function_lineage(
381 name: &str,
382 output_name: &str,
383 alias: Option<&str>,
384 column_aliases: &[String],
385) -> SourceLineage {
386 let columns = if column_aliases.is_empty() {
387 vec![if output_name.is_empty() {
388 name.rsplit('.').next().unwrap_or(name).to_string()
389 } else {
390 output_name.to_string()
391 }]
392 } else {
393 column_aliases.to_vec()
394 };
395 let qualifier = alias.map_or_else(
396 || name.rsplit('.').next().unwrap_or(name).to_string(),
397 str::to_string,
398 );
399 opaque_lineage(columns, Some(qualifier))
400}
401
402fn analyze_join_source_lineage(
403 source: &SourcePlan,
404 outer_scopes: &[&SourceLineage],
405 subqueries: &[QueryPlan],
406 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
407 universe: &mut SourceLineage,
408 required: &mut BTreeSet<BaseColumn>,
409) -> Result<SourceLineage, SQLError> {
410 let SourcePlan::Join {
411 left,
412 right,
413 on,
414 using,
415 natural,
416 alias,
417 column_aliases,
418 ..
419 } = source
420 else {
421 unreachable!("join lineage helper requires a join source")
422 };
423 let left = analyze_source_lineage(left, outer_scopes, subqueries, ctes, universe, required)?;
424 let mut right_scopes = vec![&left];
425 right_scopes.extend_from_slice(outer_scopes);
426 let right = analyze_source_lineage(right, &right_scopes, subqueries, ctes, universe, required)?;
427 if let Some(on) = on {
428 let inputs = join_lineage(left.clone(), right.clone(), None, false, None, &[]);
429 let mut condition_scopes = vec![&inputs];
430 condition_scopes.extend_from_slice(outer_scopes);
431 collect_expression_and_subqueries(
432 on,
433 &condition_scopes,
434 false,
435 subqueries,
436 ctes,
437 universe,
438 required,
439 )?;
440 }
441 if let Some(using) = using {
442 for column in &using.columns {
443 left.require_unqualified(column, required);
444 right.require_unqualified(column, required);
445 }
446 } else if *natural {
447 for column in left
448 .output
449 .iter()
450 .filter(|left| right.output.iter().any(|right| right.name == left.name))
451 {
452 left.require_unqualified(&column.name, required);
453 right.require_unqualified(&column.name, required);
454 }
455 }
456 Ok(join_lineage(
457 left,
458 right,
459 using.as_ref(),
460 *natural,
461 alias.as_deref(),
462 column_aliases,
463 ))
464}
465
466fn analyze_function_group_lineage(
467 source: &SourcePlan,
468 outer_scopes: &[&SourceLineage],
469 subqueries: &[QueryPlan],
470 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
471 universe: &mut SourceLineage,
472 required: &mut BTreeSet<BaseColumn>,
473) -> Result<SourceLineage, SQLError> {
474 let SourcePlan::FunctionGroup {
475 functions,
476 alias,
477 column_aliases,
478 ..
479 } = source
480 else {
481 unreachable!("function-group lineage helper requires a function group")
482 };
483 for expression in functions.iter().flat_map(|function| &function.args) {
484 collect_expression_and_subqueries(
485 expression,
486 outer_scopes,
487 false,
488 subqueries,
489 ctes,
490 universe,
491 required,
492 )?;
493 }
494 let columns = if column_aliases.is_empty() {
495 functions
496 .iter()
497 .flat_map(|function| {
498 if function.column_aliases.is_empty() {
499 vec![function.output_name.clone()]
500 } else {
501 function.column_aliases.clone()
502 }
503 })
504 .collect()
505 } else {
506 column_aliases.clone()
507 };
508 Ok(opaque_lineage(columns, alias.clone()))
509}
510
511fn analyze_source_lineage(
512 source: &SourcePlan,
513 outer_scopes: &[&SourceLineage],
514 subqueries: &[QueryPlan],
515 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
516 universe: &mut SourceLineage,
517 required: &mut BTreeSet<BaseColumn>,
518) -> Result<SourceLineage, SQLError> {
519 match source {
520 crate::plan::SourcePlan::RetainedRows(_) => Ok(SourceLineage::default()),
521 SourcePlan::Table {
522 name,
523 qualifier,
524 alias,
525 column_aliases,
526 ..
527 } => table_lineage(name, qualifier, alias.as_deref(), column_aliases, ctes),
528 source @ SourcePlan::Join { .. } => {
529 analyze_join_source_lineage(source, outer_scopes, subqueries, ctes, universe, required)
530 }
531 SourcePlan::Values {
532 rows,
533 alias,
534 column_aliases,
535 ..
536 } => {
537 for expression in rows.iter().flatten() {
538 collect_expression_and_subqueries(
539 expression,
540 outer_scopes,
541 false,
542 subqueries,
543 ctes,
544 universe,
545 required,
546 )?;
547 }
548 Ok(values_lineage(rows, alias.as_deref(), column_aliases))
549 }
550 SourcePlan::Function {
551 name,
552 output_name,
553 args,
554 alias,
555 column_aliases,
556 ..
557 } => {
558 for expression in args {
559 collect_expression_and_subqueries(
560 expression,
561 outer_scopes,
562 false,
563 subqueries,
564 ctes,
565 universe,
566 required,
567 )?;
568 }
569 Ok(function_lineage(
570 name,
571 output_name,
572 alias.as_deref(),
573 column_aliases,
574 ))
575 }
576 source @ SourcePlan::FunctionGroup { .. } => analyze_function_group_lineage(
577 source,
578 outer_scopes,
579 subqueries,
580 ctes,
581 universe,
582 required,
583 ),
584 SourcePlan::Subquery {
585 body,
586 alias,
587 column_aliases,
588 ..
589 } => {
590 analyze_query_plan(body, ctes, outer_scopes, universe, required)?;
591 let mut columns =
592 crate::semantics::projection::query_plan_output_columns(body).unwrap_or_default();
593 for (column, alias) in columns.iter_mut().zip(column_aliases) {
594 column.clone_from(alias);
595 }
596 Ok(opaque_lineage(columns, alias.clone()))
597 }
598 }
599}
600
601fn analyze_query_block(
602 block: &QueryBlockPlan,
603 source: Option<&SourcePlan>,
604 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
605 outer_scopes: &[&SourceLineage],
606 universe: &mut SourceLineage,
607 required: &mut BTreeSet<BaseColumn>,
608) -> Result<(), SQLError> {
609 let lineage = source.map_or_else(
610 || Ok(SourceLineage::default()),
611 |source| {
612 analyze_source_lineage(
613 source,
614 outer_scopes,
615 &block.subqueries,
616 ctes,
617 universe,
618 required,
619 )
620 },
621 )?;
622 universe.include_tables(&lineage);
623 let mut scopes = vec![&lineage];
624 scopes.extend_from_slice(outer_scopes);
625 for column in block
626 .privilege_columns
627 .iter()
628 .filter(|_| ctes.include_authorization_only_columns)
629 {
630 let expression = column.qualifier().map_or_else(
631 || ScalarExpr::Column(column.column().to_string().into()),
632 |qualifier| ScalarExpr::qualified_column(qualifier, column.column()),
633 );
634 collect_expression_columns(&expression, &scopes, false, required);
635 }
636 for projection in &block.projections {
637 collect_expression_and_subqueries(
638 &projection.expr,
639 &scopes,
640 true,
641 &block.subqueries,
642 ctes,
643 universe,
644 required,
645 )?;
646 }
647 for expression in block
648 .r#where
649 .iter()
650 .chain(block.group_by.iter())
651 .chain(block.grouping_sets.iter().flatten())
652 .chain(block.having.iter())
653 .chain(block.order_by.iter().map(|order| &order.expr))
654 .chain(block.distinct_on.iter())
655 .chain(block.limit.iter())
656 .chain(block.offset.iter())
657 {
658 collect_expression_and_subqueries(
659 expression,
660 &scopes,
661 false,
662 &block.subqueries,
663 ctes,
664 universe,
665 required,
666 )?;
667 }
668 Ok(())
669}
670
671fn analyze_query_plan(
672 plan: &QueryPlan,
673 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
674 outer_scopes: &[&SourceLineage],
675 universe: &mut SourceLineage,
676 required: &mut BTreeSet<BaseColumn>,
677) -> Result<(), SQLError> {
678 let mut root_ctes = ctes.reborrow();
679 root_ctes.resolution.lookup_mode = if plan.relations_bound {
680 crate::catalog::resolution::RelationLookupMode::Bound
681 } else {
682 crate::catalog::resolution::RelationLookupMode::Dynamic
683 };
684 if let Some(subject) = &plan.relation_privilege_subject {
685 root_ctes.relation_privilege_subject = Some(subject.clone());
686 let mut owned_universe = SourceLineage::default();
687 let mut owned_required = BTreeSet::new();
688 analyze_query_plan_in_scope(
689 plan,
690 &root_ctes,
691 outer_scopes,
692 &mut owned_universe,
693 &mut owned_required,
694 )?;
695 return ensure_required_select(&owned_universe, &owned_required, &root_ctes);
696 }
697 analyze_query_plan_in_scope(plan, &root_ctes, outer_scopes, universe, required)
698}
699
700fn analyze_query_plan_in_scope(
701 plan: &QueryPlan,
702 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
703 outer_scopes: &[&SourceLineage],
704 universe: &mut SourceLineage,
705 required: &mut BTreeSet<BaseColumn>,
706) -> Result<(), SQLError> {
707 let reachable = crate::semantics::reachable_plan_cte_names(plan);
708 let mut root_ctes = ctes.reborrow();
709 let mut preceding_ctes = root_ctes.reborrow();
710 for cte in &plan.ctes {
711 if reachable.contains(&cte.name) {
712 let mut definition_ctes = preceding_ctes.reborrow();
713 if cte.recursive {
714 for local in &plan.ctes {
715 definition_ctes.insert_deferred_ref(local);
716 }
717 }
718 if let Some(query) = cte.body.query() {
719 analyze_query_plan(query, &definition_ctes, outer_scopes, universe, required)?;
720 }
721 }
722 preceding_ctes.insert_deferred_ref(cte);
723 }
724 for cte in &plan.ctes {
725 root_ctes.insert_deferred_ref(cte);
726 }
727 match &plan.root {
728 RelationalPlan::QueryBlock(block) => analyze_query_block(
729 block,
730 block.from.as_ref(),
731 &root_ctes,
732 outer_scopes,
733 universe,
734 required,
735 ),
736 RelationalPlan::SetOp {
737 left,
738 right,
739 order_by,
740 limit,
741 offset,
742 subqueries,
743 ..
744 } => {
745 analyze_query_plan(left, &root_ctes, outer_scopes, universe, required)?;
746 analyze_query_plan(right, &root_ctes, outer_scopes, universe, required)?;
747 let result_scope = opaque_lineage(
748 crate::semantics::projection::query_plan_output_columns(left).unwrap_or_default(),
749 None,
750 );
751 let mut scopes = vec![&result_scope];
752 scopes.extend_from_slice(outer_scopes);
753 for expression in order_by
754 .iter()
755 .map(|order| &order.expr)
756 .chain(limit.iter().map(Box::as_ref))
757 .chain(offset.iter().map(Box::as_ref))
758 {
759 collect_expression_and_subqueries(
760 expression, &scopes, false, subqueries, &root_ctes, universe, required,
761 )?;
762 }
763 Ok(())
764 }
765 RelationalPlan::Values { rows, subqueries } => {
766 for expression in rows.iter().flatten() {
767 collect_expression_and_subqueries(
768 expression,
769 outer_scopes,
770 false,
771 subqueries,
772 &root_ctes,
773 universe,
774 required,
775 )?;
776 }
777 Ok(())
778 }
779 }
780}
781
782pub fn ensure_select_privileges_for_query(
783 query: &QueryPlan,
784 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
785) -> Result<(), SQLError> {
786 let mut universe = SourceLineage::default();
787 let mut required = BTreeSet::new();
788 analyze_query_plan(query, ctes, &[], &mut universe, &mut required)?;
789 ensure_required_select(&universe, &required, ctes)
790}
791
792pub fn ensure_select_privileges_for_query_block(
793 statement: &QueryBlockPlan,
794 source: &SourcePlan,
795 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
796) -> Result<(), SQLError> {
797 let mut universe = SourceLineage::default();
798 let mut required = BTreeSet::new();
799 analyze_query_block(
800 statement,
801 Some(source),
802 ctes,
803 &[],
804 &mut universe,
805 &mut required,
806 )?;
807 ensure_required_select(&universe, &required, ctes)
808}
809
810pub fn ensure_select_privileges_for_source_expressions(
811 source: &SourcePlan,
812 expressions: &[&ScalarExpr],
813 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
814) -> Result<(), SQLError> {
815 let (universe, required) = source_expression_dependencies(source, expressions, ctes)?;
816 ensure_required_select(&universe, &required, ctes)
817}
818
819fn source_expression_dependencies(
820 source: &SourcePlan,
821 expressions: &[&ScalarExpr],
822 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
823) -> Result<(SourceLineage, BTreeSet<BaseColumn>), SQLError> {
824 let mut universe = SourceLineage::default();
825 let mut required = BTreeSet::new();
826 let lineage = analyze_source_lineage(
827 source,
828 &[],
829 ctes.scalar_subqueries.as_ref(),
830 ctes,
831 &mut universe,
832 &mut required,
833 )?;
834 universe.include_tables(&lineage);
835 let scopes = [&lineage];
836 for expression in expressions {
837 collect_expression_and_subqueries(
838 expression,
839 &scopes,
840 matches!(expression, ScalarExpr::QualifiedStar(_)),
841 ctes.scalar_subqueries.as_ref(),
842 ctes,
843 &mut universe,
844 &mut required,
845 )?;
846 }
847 Ok((universe, required))
848}
849
850pub fn ensure_select_privileges_for_table_expressions(
851 table: &str,
852 qualifiers: &BTreeSet<String>,
853 expressions: &[&ScalarExpr],
854 subqueries: &[QueryPlan],
855 required_columns: &[String],
856 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
857) -> Result<(), SQLError> {
858 let (universe, required) = table_expression_dependencies(
859 table,
860 qualifiers,
861 expressions,
862 subqueries,
863 required_columns,
864 ctes,
865 )?;
866 ensure_required_select(&universe, &required, ctes)
867}
868
869fn table_expression_dependencies(
870 table: &str,
871 qualifiers: &BTreeSet<String>,
872 expressions: &[&ScalarExpr],
873 subqueries: &[QueryPlan],
874 required_columns: &[String],
875 ctes: &CteScope<'_, impl AsRef<[QueryPlan]>>,
876) -> Result<(SourceLineage, BTreeSet<BaseColumn>), SQLError> {
877 let catalog = ctes.catalog;
878 let mut resolution = ctes.resolution.clone();
879 resolution.set_lookup_mode(crate::catalog::resolution::RelationLookupMode::Bound);
880 let Some(relation) = catalog.relation(&resolution, table)? else {
881 return Err(SQLError::UnknownTable(table.to_string()));
882 };
883 let canonical = relation.canonical;
884 let columns = relation.columns;
885 let system_columns = relation.kind.has_system_columns();
886 let output = columns
887 .iter()
888 .map(|column| OutputColumn {
889 name: column.clone(),
890 sources: BTreeSet::from([BaseColumn {
891 table: canonical.clone(),
892 column: column.clone(),
893 }]),
894 })
895 .collect::<Vec<_>>();
896 let lineage = SourceLineage {
897 output: output.clone(),
898 qualifiers: qualifiers
899 .iter()
900 .map(|qualifier| (qualifier.clone(), output.clone()))
901 .collect(),
902 system_qualifiers: if system_columns {
903 qualifiers
904 .iter()
905 .map(|qualifier| (qualifier.clone(), BTreeSet::from([canonical.clone()])))
906 .collect()
907 } else {
908 BTreeMap::new()
909 },
910 tables: BTreeMap::from([(canonical.clone(), columns.into_iter().collect())]),
911 };
912 let mut universe = SourceLineage::default();
913 let mut required = required_columns
914 .iter()
915 .cloned()
916 .map(|column| BaseColumn {
917 table: canonical.clone(),
918 column,
919 })
920 .collect::<BTreeSet<_>>();
921 let scopes = [&lineage];
922 for expression in expressions {
923 collect_expression_and_subqueries(
924 expression,
925 &scopes,
926 true,
927 subqueries,
928 ctes,
929 &mut universe,
930 &mut required,
931 )?;
932 }
933 if required.iter().any(|column| column.table == canonical) {
934 universe.include_tables(&lineage);
935 }
936 Ok((universe, required))
937}
938
939pub struct TargetSelectPrivilegeRequest<'a, 'expr> {
940 pub table: &'a str,
941 pub privilege_subject: Option<&'a RoleReference>,
942 pub target_qualifier: &'a str,
943 pub returning_aliases: &'a crate::ast::ReturningAliases,
944 pub expressions: &'a [&'expr ScalarExpr],
945 pub subqueries: &'a [QueryPlan],
946 pub required_columns: &'a [String],
947}