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