uqa_sql/semantics/
input_values.rs1use crate::ScalarExpr;
10
11pub 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}