Skip to main content

schema_sql_generator/common/
view_generator.rs

1use crate::common::generator_context::GeneratorContext;
2use schema_model::model::view::View;
3use std::collections::HashSet;
4
5pub trait ViewGenerator {
6    fn output_views(&self);
7}
8
9/// Splits `sql` into lowercase identifier-like tokens (letters, digits, `_`, `$`), so
10/// quoting (`"v"`, `[v]`, `` `v` ``) and schema qualification (`s.v`) don't hide a name.
11fn identifier_tokens(sql: &str) -> HashSet<String> {
12    sql.split(|c: char| !(c.is_alphanumeric() || c == '_' || c == '$'))
13        .filter(|token| !token.is_empty())
14        .map(|token| token.to_lowercase())
15        .collect()
16}
17
18/// Orders `views` so that a view whose SQL references another view comes after it (M9):
19/// emitting in declaration order fails when a view selects from a later-declared view.
20///
21/// Dependencies are found by matching each view's (case-insensitive) name against the
22/// identifiers in the other views' SQL, since view bodies are opaque SQL. Views with no
23/// dependency between them keep their declaration order. Views caught in a dependency
24/// cycle fall back to declaration order after everything orderable - no ordering
25/// satisfies a cycle, and this matches the pre-fix behavior.
26pub fn views_in_dependency_order(views: Vec<View>) -> Vec<View> {
27    let count = views.len();
28    let tokens: Vec<HashSet<String>> = views
29        .iter()
30        .map(|view| identifier_tokens(view.sql()))
31        .collect();
32    let names: Vec<String> = views
33        .iter()
34        .map(|view| view.name().to_lowercase())
35        .collect();
36
37    // dependencies[i] = indexes of the views that view i references.
38    let dependencies: Vec<Vec<usize>> = (0..count)
39        .map(|i| {
40            (0..count)
41                .filter(|&j| j != i && tokens[i].contains(&names[j]))
42                .collect()
43        })
44        .collect();
45
46    let mut emitted = vec![false; count];
47    let mut order = Vec::with_capacity(count);
48
49    while let Some(next) =
50        (0..count).find(|&i| !emitted[i] && dependencies[i].iter().all(|&d| emitted[d]))
51    {
52        emitted[next] = true;
53        order.push(next);
54    }
55
56    order.extend((0..count).filter(|&i| !emitted[i]));
57
58    let mut slots: Vec<Option<View>> = views.into_iter().map(Some).collect();
59    order.into_iter().filter_map(|i| slots[i].take()).collect()
60}
61
62pub struct DefaultViewGenerator {
63    context: GeneratorContext,
64}
65
66impl DefaultViewGenerator {
67    pub fn new(context: GeneratorContext) -> Self {
68        Self { context }
69    }
70
71    pub fn context(&self) -> &GeneratorContext {
72        &self.context
73    }
74}
75
76impl ViewGenerator for DefaultViewGenerator {
77    fn output_views(&self) {}
78}
79
80#[cfg(test)]
81mod tests {
82    use super::*;
83
84    fn view(name: &str, sql: &str) -> View {
85        View::new(None::<&str>, name, sql, None)
86    }
87
88    fn names(views: &[View]) -> Vec<&str> {
89        views.iter().map(|v| v.name()).collect()
90    }
91
92    #[test]
93    fn view_selecting_from_later_declared_view_is_moved_after_it() {
94        let ordered = views_in_dependency_order(vec![
95            view("b", "select * from a"),
96            view("a", "select 1 from users"),
97        ]);
98        assert_eq!(names(&ordered), vec!["a", "b"]);
99    }
100
101    #[test]
102    fn independent_views_keep_declaration_order() {
103        let ordered = views_in_dependency_order(vec![view("z", "select 1"), view("a", "select 2")]);
104        assert_eq!(names(&ordered), vec!["z", "a"]);
105    }
106
107    #[test]
108    fn handles_chains_quoting_qualification_and_case() {
109        let ordered = views_in_dependency_order(vec![
110            view("c", "select * from public.\"B\""),
111            view("b", "select * from [dbo].A"),
112            view("a", "select 1"),
113        ]);
114        assert_eq!(names(&ordered), vec!["a", "b", "c"]);
115    }
116
117    #[test]
118    fn name_inside_a_longer_identifier_is_not_a_dependency() {
119        let ordered = views_in_dependency_order(vec![
120            view("x", "select * from a_users"),
121            view("a", "select 1"),
122        ]);
123        assert_eq!(names(&ordered), vec!["x", "a"]);
124    }
125
126    #[test]
127    fn cycle_falls_back_to_declaration_order() {
128        let ordered = views_in_dependency_order(vec![
129            view("a", "select * from b"),
130            view("b", "select * from a"),
131            view("c", "select 1"),
132        ]);
133        assert_eq!(names(&ordered), vec!["c", "a", "b"]);
134    }
135}