Skip to main content

uqa_sql/semantics/
input_values.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Input-value traversal for output liveness, distinct from row-count demand.
8
9use crate::ScalarExpr;
10
11/// Traverse values observed by an expression. COUNT(*) consumes rows, while its FILTER and ORDER BY still consume their own input values.
12pub fn visit_input_values(expression: &ScalarExpr, visitor: &mut impl FnMut(&ScalarExpr)) {
13    let result = expression.try_visit(&mut |node| {
14        if let ScalarExpr::Func {
15            name,
16            binding,
17            args,
18            order_by,
19            filter,
20            ..
21        } = node
22        {
23            let selected = binding
24                .as_ref()
25                .map_or(name.as_str(), |binding| &binding.name);
26            if matches!(args.as_slice(), [ScalarExpr::Star])
27                && crate::semantics::is_builtin_aggregate(node)
28                && selected
29                    .rsplit('.')
30                    .next()
31                    .is_some_and(|name| name.eq_ignore_ascii_case("count"))
32            {
33                for expression in order_by
34                    .iter()
35                    .map(|order| &order.expr)
36                    .chain(filter.as_deref())
37                {
38                    visit_input_values(expression, visitor);
39                }
40                return Ok::<_, std::convert::Infallible>(false);
41            }
42        }
43        visitor(node);
44        Ok(true)
45    });
46    match result {
47        Ok(()) => {}
48        Err(never) => match never {},
49    }
50}
51
52#[cfg(test)]
53mod tests {
54    use super::visit_input_values as visit;
55    use super::*;
56
57    fn expression(sql: &str) -> ScalarExpr {
58        let crate::plan::UnifiedPlan::Query(query) =
59            crate::plan::UnifiedPlan::lower(crate::compile(sql).unwrap().remove(0))
60        else {
61            panic!("query");
62        };
63        let crate::plan::RelationalPlan::QueryBlock(mut block) = query.root else {
64            panic!("block");
65        };
66        block.projections.remove(0).expr
67    }
68
69    #[test]
70    fn row_count_star_does_not_demand_values_but_keeps_filter_and_ordering() {
71        for sql in [
72            "SELECT count(*)",
73            "SELECT pg_catalog.count(*)",
74            "SELECT 2+count(*)",
75        ] {
76            let mut stars = 0;
77            visit(&expression(sql), &mut |node| {
78                stars += usize::from(matches!(node, ScalarExpr::Star));
79            });
80            assert_eq!(stars, 0, "{sql}");
81        }
82        let mut count = expression("SELECT count(*) FILTER (WHERE keep > 0)");
83        let ScalarExpr::Func { order_by, .. } =
84            expression("SELECT count(value ORDER BY rank DESC)")
85        else {
86            panic!("call");
87        };
88        if let ScalarExpr::Func {
89            order_by: target, ..
90        } = &mut count
91        {
92            *target = order_by;
93        }
94        let mut names = Vec::new();
95        visit(&count, &mut |node| {
96            if let ScalarExpr::Column(name) = node {
97                names.push(name.clone());
98            }
99        });
100        assert_eq!(names, ["rank", "keep"]);
101    }
102
103    #[test]
104    fn selected_user_routine_and_whole_row_keep_their_value_demand() {
105        let mut count = expression("SELECT count(*)");
106        if let ScalarExpr::Func { binding, .. } = &mut count {
107            let mut user = crate::ast::FunctionBinding::builtin_by_name("count", None);
108            user.builtin = false;
109            user.object_id = Some([7; 16]);
110            *binding = Some(user);
111        }
112        let mut stars = 0;
113        visit(&count, &mut |node| {
114            stars += usize::from(matches!(node, ScalarExpr::Star));
115        });
116        assert_eq!(stars, 1);
117        for sql in ["SELECT count(q)", "SELECT count(q.*)"] {
118            let mut reads = 0;
119            visit(&expression(sql), &mut |node| {
120                reads += usize::from(matches!(
121                    node,
122                    ScalarExpr::Column(_) | ScalarExpr::QualifiedStar(_)
123                ));
124            });
125            assert_eq!(reads, 1, "{sql}");
126        }
127    }
128}