feat(schema): ingest CREATE VIEW and CREATE TABLE … AS SELECT

davidsmfreire · claude · davidsmfreire · commit 257fc470a613 · 2026-04-25T00:02:10.000+01:00
Real-world schema dumps lean heavily on views; the loader previously
only saw CREATE TABLE so any reference to a view was reported as
"table not found" — a false positive.

Three coverage extensions in load_schema:
- CREATE VIEW with an explicit column list `(a, b)` registers those
  names verbatim. References to the underlying body's column names
  (e.g. `SELECT id FROM renamed_view` when the view does
  `SELECT id AS uid`) correctly fail.
- CREATE VIEW without an explicit list infers names from the body's
  projection — including aliased items (`SELECT id AS uid` exposes
  `uid`).
- CREATE TABLE … AS SELECT (CTAS): when the original CREATE TABLE has
  no explicit column list but a `query: Some(...)`, columns are
  inferred from the source query's projection, same way views do.

A small `project_column_names` helper walks the Query/SetExpr tree
returning owned strings (the validator-side `project_columns` returns
borrowed `&amp;str` tied to the AST lifetime, which doesn't fit schema
ingestion). UNION-shaped bodies use the left-branch projection per
SQL standard.

5 tests cover view-with-explicit-list (valid + invalid via body
names), view-without-list, view with aliased projection, CTAS, and
qualified view names (analytics.user_view).

Co-Authored-By: Claude Opus 4.7 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/sqlshield/src/schema/sql.rs b/sqlshield/src/schema/sql.rs
@@ -1,5 +1,8 @@
 use sqlparser::{
-    ast::{AlterTableOperation, ColumnDef, ObjectName, Statement},
+    ast::{
+        AlterTableOperation, ColumnDef, Expr, ObjectName, Query, SelectItem, SetExpr, Statement,
+        ViewColumnDef,
+    },
     dialect::GenericDialect,
     parser::Parser,
 };
@@ -16,14 +19,27 @@ pub fn load_schema(schema: &[u8]) -> Result<super::TablesAndColumns> {
     let mut tables: HashMap<String, HashSet<String>> = HashMap::new();
     for statement in statements {
         match statement {
-            Statement::CreateTable { columns, name, .. } => {
-                ingest_create_table(&name, &columns, &mut tables);
+            Statement::CreateTable {
+                columns,
+                name,
+                query,
+                ..
+            } => {
+                ingest_create_table(&name, &columns, query.as_deref(), &mut tables);
             }
             Statement::AlterTable {
                 name, operations, ..
             } => {
                 apply_alters(&name, &operations, &mut tables);
             }
+            Statement::CreateView {
+                name,
+                columns,
+                query,
+                ..
+            } => {
+                ingest_create_view(&name, &columns, &query, &mut tables);
+            }
             _ => {}
         }
     }
@@ -33,13 +49,23 @@ pub fn load_schema(schema: &[u8]) -> Result<super::TablesAndColumns> {
 fn ingest_create_table(
     name: &ObjectName,
     columns: &[ColumnDef],
+    query: Option<&Query>,
     tables: &mut HashMap<String, HashSet<String>>,
 ) {
     let Some(last_ident) = name.0.last() else {
         return;
     };
-    let columns_set: HashSet<String> =
-        HashSet::from_iter(columns.iter().map(|e| e.name.value.clone()));
+
+    // CREATE TABLE … AS SELECT carries no explicit column list; infer the
+    // names from the source query's projection. Plain CREATE TABLE uses
+    // the explicit list. If both are present, the explicit list wins.
+    let columns_set: HashSet<String> = if !columns.is_empty() {
+        columns.iter().map(|e| e.name.value.clone()).collect()
+    } else if let Some(q) = query {
+        project_column_names(q).into_iter().collect()
+    } else {
+        HashSet::new()
+    };
 
     // Store the bare table name so unqualified queries resolve; if the
     // schema was declared as `schema.table`, ALSO store the fully
@@ -50,6 +76,69 @@ fn ingest_create_table(
     }
 }
 
+fn ingest_create_view(
+    name: &ObjectName,
+    columns: &[ViewColumnDef],
+    query: &Query,
+    tables: &mut HashMap<String, HashSet<String>>,
+) {
+    let Some(last_ident) = name.0.last() else {
+        return;
+    };
+    // Explicit column list `CREATE VIEW v(a, b) AS …` overrides whatever
+    // names the body projects.
+    let columns_set: HashSet<String> = if !columns.is_empty() {
+        columns.iter().map(|c| c.name.value.clone()).collect()
+    } else {
+        project_column_names(query).into_iter().collect()
+    };
+    tables.insert(last_ident.value.clone(), columns_set.clone());
+    if name.0.len() > 1 {
+        tables.insert(display_name(name), columns_set);
+    }
+}
+
+/// Owned-string version of `validation::project_columns`. Used at schema-
+/// ingestion time to capture the column names that a view or CTAS body
+/// projects.
+fn project_column_names(query: &Query) -> Vec<String> {
+    project_names_of_body(query.body.as_ref())
+}
+
+fn project_names_of_body(body: &SetExpr) -> Vec<String> {
+    let mut names = Vec::new();
+    match body {
+        SetExpr::Select(select_box) => {
+            for item in &select_box.projection {
+                match item {
+                    SelectItem::UnnamedExpr(expr) => match expr {
+                        Expr::Identifier(ident) => names.push(ident.value.clone()),
+                        Expr::CompoundIdentifier(idents) => {
+                            if let Some(last) = idents.last() {
+                                names.push(last.value.clone());
+                            }
+                        }
+                        _ => {}
+                    },
+                    SelectItem::ExprWithAlias { alias, .. } => {
+                        names.push(alias.value.clone());
+                    }
+                    _ => {}
+                }
+            }
+        }
+        // For UNION/etc., the output names are taken from the left branch.
+        SetExpr::SetOperation { left, .. } => {
+            names.extend(project_names_of_body(left.as_ref()));
+        }
+        SetExpr::Query(inner) => {
+            names.extend(project_column_names(inner.as_ref()));
+        }
+        _ => {}
+    }
+    names
+}
+
 fn apply_alters(
     name: &ObjectName,
     operations: &[AlterTableOperation],
diff --git a/sqlshield/tests/schema_views.rs b/sqlshield/tests/schema_views.rs
@@ -0,0 +1,74 @@
+//! Schema ingestion: CREATE VIEW (with + without explicit column list)
+//! and CREATE TABLE … AS SELECT.
+
+use sqlshield::validate_query;
+
+#[test]
+fn view_with_explicit_column_list_publishes_those_names() {
+    let schema = "
+        CREATE TABLE users (id INT, name VARCHAR(255));
+        CREATE VIEW user_summary (uid, full_name) AS
+            SELECT id, name FROM users;
+    ";
+    // Explicit column names are visible.
+    let valid = validate_query("SELECT uid, full_name FROM user_summary", schema).unwrap();
+    assert!(valid.is_empty(), "got: {valid:?}");
+
+    // The body's original column names are NOT visible through the view.
+    let invalid = validate_query("SELECT id FROM user_summary", schema).unwrap();
+    assert!(
+        invalid.iter().any(|e| e.contains("`id`")),
+        "got: {invalid:?}"
+    );
+}
+
+#[test]
+fn view_without_explicit_columns_infers_from_body() {
+    let schema = "
+        CREATE TABLE users (id INT, name VARCHAR(255));
+        CREATE VIEW active_users AS SELECT id, name FROM users;
+    ";
+    let valid = validate_query("SELECT id, name FROM active_users", schema).unwrap();
+    assert!(valid.is_empty(), "got: {valid:?}");
+
+    let invalid = validate_query("SELECT email FROM active_users", schema).unwrap();
+    assert!(
+        invalid.iter().any(|e| e.contains("`email`")),
+        "got: {invalid:?}"
+    );
+}
+
+#[test]
+fn view_with_aliased_projection() {
+    // `SELECT id AS uid` projects `uid` (alias) — the view's column should be
+    // `uid`, not the underlying `id`.
+    let schema = "
+        CREATE TABLE users (id INT);
+        CREATE VIEW renamed AS SELECT id AS uid FROM users;
+    ";
+    let valid = validate_query("SELECT uid FROM renamed", schema).unwrap();
+    assert!(valid.is_empty(), "got: {valid:?}");
+}
+
+#[test]
+fn create_table_as_select_publishes_projected_columns() {
+    let schema = "
+        CREATE TABLE users (id INT, name VARCHAR(255));
+        CREATE TABLE archive AS SELECT id, name FROM users;
+    ";
+    let valid = validate_query("SELECT id, name FROM archive", schema).unwrap();
+    assert!(valid.is_empty(), "got: {valid:?}");
+
+    let invalid = validate_query("SELECT email FROM archive", schema).unwrap();
+    assert!(invalid.iter().any(|e| e.contains("`email`")));
+}
+
+#[test]
+fn view_can_be_referenced_by_qualified_name() {
+    let schema = "
+        CREATE TABLE users (id INT);
+        CREATE VIEW analytics.user_view AS SELECT id FROM users;
+    ";
+    let valid = validate_query("SELECT id FROM analytics.user_view", schema).unwrap();
+    assert!(valid.is_empty(), "got: {valid:?}");
+}
