feat: implement view support

Author: LeadcodeDev

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "sqlx-gen"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 description = "Generate Rust structs from database schema introspection"
 license = "MIT"

Cargo.toml

@@ -2,7 +2,7 @@
 
 Generate Rust structs from your database schema — with correct types, derives, and `sqlx::FromRow` annotations.
 
-Supports **PostgreSQL**, **MySQL**, and **SQLite**. Introspects tables, enums, composite types, and domains.
+Supports **PostgreSQL**, **MySQL**, and **SQLite**. Introspects tables, views, enums, composite types, and domains.
 
 [![Crates.io](https://img.shields.io/crates/v/sqlx-gen.svg)](https://crates.io/crates/sqlx-gen)
 [![docs.rs](https://docs.rs/sqlx-gen/badge.svg)](https://docs.rs/sqlx-gen)
@@ -19,6 +19,7 @@ Supports **PostgreSQL**, **MySQL**, and **SQLite**. Introspects tables, enums, c
 - Correct nullable handling (`Option<T>`)
 - Custom derives (`--derives Serialize,Deserialize`)
 - Type overrides (`--type-overrides jsonb=MyType`)
+- SQL views support (`--views`)
 - Table filtering (`--tables users,orders`)
 - Single-file or multi-file output
 - Dry-run mode (preview on stdout)
@@ -51,6 +52,11 @@ sqlx-gen -u sqlite:./local.db -o src/models
 sqlx-gen -u postgres://... --derives Serialize,Deserialize -o src/models
 ```
 
+### Include SQL views
+```sh
+sqlx-gen -u postgres://... --views -o src/models
+```
+
 ### Dry run (preview without writing)
 ```sh
 sqlx-gen -u postgres://... --dry-run
@@ -66,6 +72,7 @@ sqlx-gen -u postgres://... --dry-run
 | `--derives` | | Additional derive macros (comma-separated) | none |
 | `--type-overrides` | | Type overrides `sql_type=RustType` (comma-separated) | none |
 | `--tables` | | Only generate these tables (comma-separated) | all |
+| `--views` | | Also generate structs for SQL views | false |
 | `--single-file` | | Write everything to a single `models.rs` | false |
 | `--dry-run` | | Print to stdout, don't write files | false |
 

README.md

@@ -33,6 +33,10 @@ pub struct Args {
     #[arg(long, value_delimiter = ',')]
     pub tables: Option<Vec<String>>,
 
+    /// Also generate structs for SQL views
+    #[arg(long)]
+    pub views: bool,
+
     /// Print to stdout without writing files
     #[arg(long)]
     pub dry_run: bool,
@@ -85,6 +89,7 @@ mod tests {
             type_overrides: vec![],
             single_file: false,
             tables: None,
+            views: false,
             dry_run: false,
         }
     }
@@ -98,6 +103,7 @@ mod tests {
             type_overrides: overrides.into_iter().map(|s| s.to_string()).collect(),
             single_file: false,
             tables: None,
+            views: false,
             dry_run: false,
         }
     }

src/cli.rs

@@ -94,6 +94,21 @@ pub fn generate(
         });
     }
 
+    // Generate struct files for each view
+    for view in &schema_info.views {
+        let (tokens, imports) =
+            struct_gen::generate_struct(view, db_kind, schema_info, extra_derives, type_overrides);
+        let imports = filter_imports(&imports, single_file);
+        let code = format_tokens_with_imports(&tokens, &imports);
+        let module_name = normalize_module_name(&view.name);
+        let origin = format!("View: {}.{}", view.schema_name, view.name);
+        files.push(GeneratedFile {
+            filename: format!("{}.rs", module_name),
+            origin: Some(origin),
+            code,
+        });
+    }
+
     // Generate types file (enums, composites, domains)
     // Each item is formatted individually so we can insert blank lines between them.
     let mut types_blocks: Vec<String> = Vec::new();
@@ -680,4 +695,88 @@ mod tests {
             assert!(parse_result.is_ok(), "Failed to parse {}: {:?}", f.filename, parse_result.err());
         }
     }
+
+    // ========== generate() — views ==========
+
+    fn make_view(name: &str, columns: Vec<ColumnInfo>) -> TableInfo {
+        TableInfo {
+            schema_name: "public".to_string(),
+            name: name.to_string(),
+            columns,
+        }
+    }
+
+    #[test]
+    fn test_generate_one_view() {
+        let schema = SchemaInfo {
+            views: vec![make_view("active_users", vec![make_col("id", "int4")])],
+            ..Default::default()
+        };
+        let files = generate(&schema, DatabaseKind::Postgres, &[], &HashMap::new(), false);
+        assert_eq!(files.len(), 1);
+        assert_eq!(files[0].filename, "active_users.rs");
+    }
+
+    #[test]
+    fn test_generate_view_origin() {
+        let schema = SchemaInfo {
+            views: vec![make_view("active_users", vec![make_col("id", "int4")])],
+            ..Default::default()
+        };
+        let files = generate(&schema, DatabaseKind::Postgres, &[], &HashMap::new(), false);
+        assert_eq!(files[0].origin, Some("View: public.active_users".to_string()));
+    }
+
+    #[test]
+    fn test_generate_tables_and_views() {
+        let schema = SchemaInfo {
+            tables: vec![make_table("users", vec![make_col("id", "int4")])],
+            views: vec![make_view("active_users", vec![make_col("id", "int4")])],
+            ..Default::default()
+        };
+        let files = generate(&schema, DatabaseKind::Postgres, &[], &HashMap::new(), false);
+        assert_eq!(files.len(), 2);
+    }
+
+    #[test]
+    fn test_generate_view_valid_rust() {
+        let schema = SchemaInfo {
+            views: vec![make_view("active_users", vec![
+                make_col("id", "int4"),
+                make_col("name", "text"),
+            ])],
+            ..Default::default()
+        };
+        let files = generate(&schema, DatabaseKind::Postgres, &[], &HashMap::new(), false);
+        let parse_result = syn::parse_file(&files[0].code);
+        assert!(parse_result.is_ok(), "Failed to parse: {:?}", parse_result.err());
+    }
+
+    #[test]
+    fn test_generate_view_nullable_column() {
+        let schema = SchemaInfo {
+            views: vec![make_view("v", vec![ColumnInfo {
+                name: "email".to_string(),
+                data_type: "text".to_string(),
+                udt_name: "text".to_string(),
+                is_nullable: true,
+                ordinal_position: 0,
+                schema_name: "public".to_string(),
+            }])],
+            ..Default::default()
+        };
+        let files = generate(&schema, DatabaseKind::Postgres, &[], &HashMap::new(), false);
+        assert!(files[0].code.contains("Option<String>"));
+    }
+
+    #[test]
+    fn test_generate_view_single_file_mode() {
+        let schema = SchemaInfo {
+            tables: vec![make_table("users", vec![make_col("id", "int4")])],
+            views: vec![make_view("active_users", vec![make_col("id", "int4")])],
+            ..Default::default()
+        };
+        let files = generate(&schema, DatabaseKind::Postgres, &[], &HashMap::new(), true);
+        assert_eq!(files.len(), 2);
+    }
 }

src/codegen/mod.rs

@@ -47,6 +47,7 @@ pub struct DomainInfo {
 #[derive(Debug, Clone, Default)]
 pub struct SchemaInfo {
     pub tables: Vec<TableInfo>,
+    pub views: Vec<TableInfo>,
     pub enums: Vec<EnumInfo>,
     pub composite_types: Vec<CompositeTypeInfo>,
     pub domains: Vec<DomainInfo>,

src/introspect/mod.rs

@@ -3,12 +3,22 @@ use sqlx::MySqlPool;
 
 use super::{ColumnInfo, EnumInfo, SchemaInfo, TableInfo};
 
-pub async fn introspect(pool: &MySqlPool, schemas: &[String]) -> Result<SchemaInfo> {
+pub async fn introspect(
+    pool: &MySqlPool,
+    schemas: &[String],
+    include_views: bool,
+) -> Result<SchemaInfo> {
     let tables = fetch_tables(pool, schemas).await?;
+    let views = if include_views {
+        fetch_views(pool, schemas).await?
+    } else {
+        Vec::new()
+    };
     let enums = extract_enums(&tables);
 
     Ok(SchemaInfo {
         tables,
+        views,
         enums,
         composite_types: Vec::new(),
         domains: Vec::new(),
@@ -71,6 +81,61 @@ async fn fetch_tables(pool: &MySqlPool, schemas: &[String]) -> Result<Vec<TableI
     Ok(tables)
 }
 
+async fn fetch_views(pool: &MySqlPool, schemas: &[String]) -> Result<Vec<TableInfo>> {
+    let placeholders: Vec<String> = (0..schemas.len()).map(|_| "?".to_string()).collect();
+    let query = format!(
+        r#"
+        SELECT
+            c.TABLE_SCHEMA,
+            c.TABLE_NAME,
+            c.COLUMN_NAME,
+            c.DATA_TYPE,
+            c.COLUMN_TYPE,
+            c.IS_NULLABLE,
+            c.ORDINAL_POSITION
+        FROM information_schema.COLUMNS c
+        JOIN information_schema.TABLES t
+            ON t.TABLE_SCHEMA = c.TABLE_SCHEMA
+            AND t.TABLE_NAME = c.TABLE_NAME
+            AND t.TABLE_TYPE = 'VIEW'
+        WHERE c.TABLE_SCHEMA IN ({})
+        ORDER BY c.TABLE_SCHEMA, c.TABLE_NAME, c.ORDINAL_POSITION
+        "#,
+        placeholders.join(",")
+    );
+
+    let mut q = sqlx::query_as::<_, (String, String, String, String, String, String, u32)>(&query);
+    for schema in schemas {
+        q = q.bind(schema);
+    }
+    let rows = q.fetch_all(pool).await?;
+
+    let mut views: Vec<TableInfo> = Vec::new();
+    let mut current_key: Option<(String, String)> = None;
+
+    for (schema, table, col_name, data_type, column_type, nullable, ordinal) in rows {
+        let key = (schema.clone(), table.clone());
+        if current_key.as_ref() != Some(&key) {
+            current_key = Some(key);
+            views.push(TableInfo {
+                schema_name: schema.clone(),
+                name: table.clone(),
+                columns: Vec::new(),
+            });
+        }
+        views.last_mut().unwrap().columns.push(ColumnInfo {
+            name: col_name,
+            data_type,
+            udt_name: column_type,
+            is_nullable: nullable == "YES",
+            ordinal_position: ordinal as i32,
+            schema_name: schema,
+        });
+    }
+
+    Ok(views)
+}
+
 /// Extract inline ENUMs from column types.
 /// MySQL ENUM('a','b','c') in COLUMN_TYPE gets extracted to an EnumInfo
 /// keyed by table_name + column_name.

src/introspect/mysql.rs

@@ -3,14 +3,24 @@ use sqlx::PgPool;
 
 use super::{ColumnInfo, CompositeTypeInfo, DomainInfo, EnumInfo, SchemaInfo, TableInfo};
 
-pub async fn introspect(pool: &PgPool, schemas: &[String]) -> Result<SchemaInfo> {
+pub async fn introspect(
+    pool: &PgPool,
+    schemas: &[String],
+    include_views: bool,
+) -> Result<SchemaInfo> {
     let tables = fetch_tables(pool, schemas).await?;
+    let views = if include_views {
+        fetch_views(pool, schemas).await?
+    } else {
+        Vec::new()
+    };
     let enums = fetch_enums(pool, schemas).await?;
     let composite_types = fetch_composite_types(pool, schemas).await?;
     let domains = fetch_domains(pool, schemas).await?;
 
     Ok(SchemaInfo {
         tables,
+        views,
         enums,
         composite_types,
         domains,
@@ -67,6 +77,56 @@ async fn fetch_tables(pool: &PgPool, schemas: &[String]) -> Result<Vec<TableInfo
     Ok(tables)
 }
 
+async fn fetch_views(pool: &PgPool, schemas: &[String]) -> Result<Vec<TableInfo>> {
+    let rows = sqlx::query_as::<_, (String, String, String, String, String, String, i32)>(
+        r#"
+        SELECT
+            c.table_schema,
+            c.table_name,
+            c.column_name,
+            c.data_type,
+            COALESCE(c.udt_name, c.data_type) as udt_name,
+            c.is_nullable,
+            c.ordinal_position
+        FROM information_schema.columns c
+        JOIN information_schema.tables t
+            ON t.table_schema = c.table_schema
+            AND t.table_name = c.table_name
+            AND t.table_type = 'VIEW'
+        WHERE c.table_schema = ANY($1)
+        ORDER BY c.table_schema, c.table_name, c.ordinal_position
+        "#,
+    )
+    .bind(schemas)
+    .fetch_all(pool)
+    .await?;
+
+    let mut views: Vec<TableInfo> = Vec::new();
+    let mut current_key: Option<(String, String)> = None;
+
+    for (schema, table, col_name, data_type, udt_name, nullable, ordinal) in rows {
+        let key = (schema.clone(), table.clone());
+        if current_key.as_ref() != Some(&key) {
+            current_key = Some(key);
+            views.push(TableInfo {
+                schema_name: schema.clone(),
+                name: table.clone(),
+                columns: Vec::new(),
+            });
+        }
+        views.last_mut().unwrap().columns.push(ColumnInfo {
+            name: col_name,
+            data_type,
+            udt_name,
+            is_nullable: nullable == "YES",
+            ordinal_position: ordinal,
+            schema_name: schema,
+        });
+    }
+
+    Ok(views)
+}
+
 async fn fetch_enums(pool: &PgPool, schemas: &[String]) -> Result<Vec<EnumInfo>> {
     let rows = sqlx::query_as::<_, (String, String, String)>(
         r#"