Skip to main content

uqa_sql/semantics/
privileges.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Semantic base-column privilege analysis for query sources.
8
9pub 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}